use standard released Xantham

Author: houstonhaynes

.github/workflows/publish.yml

@@ -28,7 +28,7 @@ jobs:
       - uses: actions/setup-dotnet@v6
         with:
           global-json-file: global.json
-      - name: Check public Fable support helpers
+      - name: Check released Fable binding support
         run: dotnet run --project tools/NuGetRelease -- support
       - name: Retain support verification evidence
         if: always()

config/nuget-release.json

@@ -5,7 +5,7 @@
   "projectUrl": "https://fsprojects.github.io/FSharp.CloudEdge/",
   "authors": "FSharp.CloudEdge Contributors",
   "publicDependencies": {
-    "Xantham.Fable.Core": "0.1.1",
-    "Xantham.Fable.Core.TS": "0.1.1"
+    "Xantham.Fable.Core": "0.1.0",
+    "Xantham.Fable.Core.TS": "0.1.0"
   }
 }

docs/nuget-release.md

@@ -4,21 +4,13 @@ FSharp.CloudEdge's first release targets **0.1.0** for the 47 projects selected
 
 NuGet account ownership and publishing authorization are setup tasks independent of GitHub repository administration. This workflow uses **NuGet Trusted Publishing** with GitHub OIDC. GitHub obtains temporary publishing credentials for each run.
 
-## Current release blocker
+## Release dependencies and validation
 
-The public `Xantham.Fable.Core` and `Xantham.Fable.Core.TS` 0.1.0 packages omit their `fable/` source assets. A consumer of `Xantham.Fable.Core` builds successfully with .NET but fails during Fable compilation of `TypeKeyOf.create` with `Cannot find inline member: XanthamFableCore.TypeKeyOf_create`. Erased binding examples can still compile, so those alone do not establish that the support package works.
+The release uses the published **0.1.0** versions of `Xantham.Fable.Core` and `Xantham.Fable.Core.TS` from nuget.org. `publicDependencies` in `config/nuget-release.json` records those versions. Publishing CloudEdge does not require publishing or modifying Xantham.
 
-Reproduce using only public support dependencies:
+Release validation builds the 19 site example projects against the candidate CloudEdge packages and public external dependencies, then compiles the Fable examples and checks the site's code snippets. Isolated package caches and resolved-package reports make those checks reproducible. The intended first CloudEdge release remains **0.1.0** until its packages have been published successfully.
 
-```bash
-dotnet run --project tools/NuGetRelease -- support
-```
-
-The probe uses `tests/SupportPackage/Smoke.fs` and `UpstreamHelpers.fs`. Its staged project, isolated package cache, and logs are under `artifacts/nuget-release/0.1.0/public-support/`. The release workflow requires this check to pass before publishing.
-
-The upstream packaging correction includes the project and source assets required by [Fable library packaging](https://fable.io/docs/your-fable-project/author-a-fable-library.html). `publicDependencies` in `config/nuget-release.json` now selects **0.1.1** for both support packages. Locally packed corrected packages pass the helper compilation probe; the upstream maintainer still needs to publish them before the public check can pass. Existing NuGet versions cannot be replaced. CloudEdge's intended first release remains 0.1.0.
-
-To test an upstream packaging fix before publication, pass `--support-feed /absolute/path/to/packages` to `support`, `pack`, and `examples --fable`. These commands map the two Xantham package IDs to that explicit local feed and use isolated caches. This is local evidence only: the GitHub workflow uses public support packages, and `examples --public` rejects a local support feed.
+The `support` check restores both public Xantham packages, compiles `tests/SupportPackage/Smoke.fs` with .NET and Fable, and executes its key-value and indexer checks in JavaScript. This covers the support bindings used by CloudEdge; upstream inline helper functions are outside this release gate.
 
 ## Restore account access
 
@@ -64,15 +56,15 @@ The job has `id-token: write` permission and calls `NuGet/login@v1` with `user:
 
 Either authorized GitHub maintainer can run this shared workflow. NuGet checks its configured policy, not whether the triggering GitHub actor has the same NuGet username. Shayan's NuGet organization membership additionally gives him package-management access and the ability to establish his own publishing policy. Organization membership associated with an organization-owned policy must remain active.
 
-If NuGet shows a seven-day activation window, complete a successful publish during that window or restart it with **Activate for 7 days** when ready. The temporary policy becomes permanently active after successful publication supplies the repository identity. The current upstream release blocker should be resolved before publishing; the activation window can be restarted. [Policy activation](https://learn.microsoft.com/en-us/nuget/nuget-org/trusted-publishing#policies-pending-full-activation).
+If NuGet shows a seven-day activation window, complete a successful publish during that window or restart it with **Activate for 7 days** when ready. The temporary policy becomes permanently active after successful publication supplies the repository identity. [Policy activation](https://learn.microsoft.com/en-us/nuget/nuget-org/trusted-publishing#policies-pending-full-activation).
 
 ## Candidate package preparation
 
 The F# release tool reads the selected solution, orders packages by dependency, and stages clean projects from checked-in source. Generator-only tools and the other unselected projects under `src/` are excluded. Staging leaves the contributor projects and their local generator pins unchanged.
 
 `config/nuget-release.json` pins the release and public support dependency versions. Release consumers must not restore `0.1.0-local.*` dependencies. Candidate packages contain license and README metadata; Fable packages also contain their project and source files under `fable/`.
 
-Sample projects use `0.1.*` so they can adopt stable patches. Published CloudEdge dependencies permit `[0.1.0,0.2.0)`; Xantham support dependencies permit `[0.1.1,0.2.0)`. Release validation replaces sample floats with exact candidate references and pins both support packages to the configured versions. Each consumer's `resolved-packages/*.json` report records the actual dependency versions and is retained in the workflow artifact.
+Sample projects use `0.1.*` so they can adopt stable patches. Published CloudEdge and Xantham support dependencies permit `[0.1.0,0.2.0)`. Release validation replaces sample floats with exact candidate references and pins both support packages to the configured public versions. Each consumer's `resolved-packages/*.json` report records the actual dependency versions and is retained in the workflow artifact.
 
 From the repository root:
 
@@ -90,15 +82,15 @@ The pack step compiles the large shared API assembly and can take several minute
 
 Outputs are under `artifacts/nuget-release/0.1.0`. `pack-logs/` contains the generated solutions, text logs, and MSBuild binary logs. `manifest.json` records package hashes and dependency order. Consumer validation stages all 19 site projects with package references only, uses a fresh package cache, builds them, and compiles Worker examples through Fable. Logs and partial results remain available if a check fails. This validates packaging and compilation, not hosted Cloudflare service behavior.
 
-Inspect the README, license, dependency versions, source assets, and emitted imports before publishing. The Xantham support packages are owned upstream; use their public packages and report reproducible compatibility failures to their maintainer instead of publishing replacements under those IDs.
+Inspect the README, license, dependency versions, source assets, and emitted imports before publishing. Every CloudEdge candidate includes a README identifying its package and version, with links to the documentation and source and a brief note on Fable or .NET consumption.
 
 ## Publish and verify the public feed
 
 Run the **NuGet** workflow on `main` with **publish disabled** first. It builds candidates, checks consumers, and uploads the packages and verification evidence as an artifact. Fix failures before requesting the actual release.
 
 After committing and merging fixes into `main`, use **Actions → NuGet → Run workflow**, choose `main`, and leave **publish** unchecked. The equivalent command is `gh workflow run publish.yml --ref main -f publish=false`. Here `publish.yml` is the workflow filename and `-f publish=false` supplies its boolean input. Rerunning the old tag's job uses the old commit; dispatching on `main` picks up the merged fixes without changing the package version or moving the tag. Enable **publish** only when ready to upload.
 
-GitHub runs the public support-helper probe in a separate job alongside package validation, so upstream failures appear early. The publication job requires both jobs to succeed. Package compilation uses two MSBuild processes on the standard runner; uploads remain ordered by dependency.
+GitHub runs the public support binding check alongside candidate package and consumer validation. The publication job requires both jobs to succeed. Package compilation uses two MSBuild processes on the standard runner; uploads remain ordered by dependency.
 
 When account ownership, the Trusted Publishing policy, and candidate checks are complete, push the release tag **`v0.1.0`**, or run the workflow manually with **publish enabled**. GitHub repeats validation, obtains temporary credentials, then uploads packages in the manifest's dependency order. A partial upload is possible: NuGet publication is not a transaction across 47 packages. The workflow stops on an upload error rather than silently skipping an existing version. Inspect ownership, versions, and package contents before deciding how to resume.
 

site/content/guide/packages.md

@@ -8,7 +8,7 @@ Application projects reference the FSharp.CloudEdge libraries by NuGet package I
 
 ## Release availability
 
-The first `0.1.0` release is being prepared. Package links and examples name the intended public versions; they do not assert that publication has completed. The release requires corrected Xantham support packages at `0.1.1` containing Fable source assets; see the [release blocker and reproduction](https://github.com/fsprojects/FSharp.CloudEdge/blob/main/docs/nuget-release.md#current-release-blocker). Until those dependencies are published and public validation passes, use the [contributor source build](local-build.md).
+The first `0.1.0` release is being prepared. Package links and examples name the intended public versions; they do not assert that publication has completed. The release uses the published `Xantham.Fable.Core` and `Xantham.Fable.Core.TS` **0.1.0** packages from nuget.org. Until CloudEdge publication and public validation are complete, use the [contributor source build](local-build.md).
 
 The release order is: validate candidate packages and consumers, publish dependencies before their consumers, confirm every `0.1.0` package restores from nuget.org, then announce availability. A package page appearing in search is separate from a clean restore succeeding.
 
@@ -34,7 +34,7 @@ The NuGet feed is `https://api.nuget.org/v3/index.json`. A package page such as
 
 ## Fable and npm dependencies
 
-CloudEdge's runtime and Fable support candidates contain their F# source as well as .NET assemblies. Fable uses that source when compiling the application to JavaScript. The Xantham support dependencies are restored by NuGet and also need those source assets; their current packaging issue is described above. Application developers do not run the binding generators.
+CloudEdge's runtime and Fable support candidates contain their F# source as well as .NET assemblies. Fable uses that source when compiling the application to JavaScript. NuGet restores the published Xantham support dependencies transitively. Release validation compiles the site's actual examples against this package combination. Application developers do not run the binding generators.
 
 NuGet does not install the upstream JavaScript SDKs. Where an example imports an npm SDK, install the exact package version shown on its library page. Worker-native APIs such as `Request`, D1, and R2 are supplied by the Workers runtime. The platform type declarations describe those APIs; they are not a JavaScript runtime implementation to bundle.
 

tools/NuGetRelease/Common.fs

@@ -89,14 +89,11 @@ let capture executable arguments =
     ensure (proc.ExitCode = 0) $"{executable} failed"
     result.Trim()
 
-let writeNuGetConfig path cache candidate supportFeed =
+let writeNuGetConfig path cache candidate =
     let source name url = xml "add" ["key", name; "value", url] []
     let sources = [
         xml "clear" [] []
         if candidate then source "candidate" feed
-        match supportFeed with
-        | Some directory -> source "support-candidate" (Path.GetFullPath directory)
-        | None -> ()
         source "nuget.org" "https://api.nuget.org/v3/index.json"
     ]
     let mapping name pattern = xml "packageSource" ["key", name] [xml "package" ["pattern", pattern] []]
@@ -105,10 +102,6 @@ let writeNuGetConfig path cache candidate supportFeed =
         xml "packageSources" [] sources
         xml "packageSourceMapping" [] [
             if candidate then mapping "candidate" "FSharp.CloudEdge.*"
-            if Option.isSome supportFeed then
-                xml "packageSource" ["key", "support-candidate"] [
-                    for id in config.PublicDependencies.Keys do xml "package" ["pattern", id] []
-                ]
             mapping "nuget.org" "*"
         ]
     ] |> saveXml path

tools/NuGetRelease/Consumers.fs

@@ -41,13 +41,12 @@ let audit packages =
 let installFable directory =
     let tool = Path.Combine(directory, "tools", if OperatingSystem.IsWindows() then "fable.exe" else "fable")
     let source = Path.Combine(directory, "Tools.NuGet.Config")
-    writeNuGetConfig source (Path.Combine(directory, "tool-cache")) false None
+    writeNuGetConfig source (Path.Combine(directory, "tool-cache")) false
     if not (File.Exists tool) then
         run "dotnet" ["tool"; "install"; "fable"; "--version"; "5.13.0"; "--tool-path"; Path.GetDirectoryName tool; "--configfile"; source] (Path.Combine(directory, "logs/fable-install.log"))
     tool
 
-let prepareConsumerDirectory publicFeed supportFeed =
-    ensure (not publicFeed || Option.isNone supportFeed) "Public-feed validation cannot use a local support feed"
+let prepareConsumerDirectory publicFeed =
     let mode = if publicFeed then "public" else "candidate"
     let directory = Path.Combine(output, "consumers-" + mode)
     if Directory.Exists directory then Directory.Delete(directory, true)
@@ -75,7 +74,7 @@ let prepareConsumerDirectory publicFeed supportFeed =
     ]
     doc.Root.Add supportPins
     doc.Save props
-    writeNuGetConfig (Path.Combine(directory, "NuGet.Config")) (Path.Combine(directory, "cache")) (not publicFeed) supportFeed
+    writeNuGetConfig (Path.Combine(directory, "NuGet.Config")) (Path.Combine(directory, "cache")) (not publicFeed)
     mode, directory
 
 let recordResolvedPackages directory name project =
@@ -94,8 +93,8 @@ let recordResolvedPackages directory name project =
     mkdir destination
     writeJson (Path.Combine(destination, name + ".json")) packages
 
-let buildExamples (projects: string array) publicFeed emit supportFeed =
-    let mode, directory = prepareConsumerDirectory publicFeed supportFeed
+let buildExamples (projects: string array) publicFeed emit =
+    let mode, directory = prepareConsumerDirectory publicFeed
     let tool = if emit then installFable directory else ""
     let results = ResizeArray<ConsumerResult>()
     for index, original in Array.indexed projects do
@@ -121,16 +120,15 @@ let buildExamples (projects: string array) publicFeed emit supportFeed =
     ensure (failures = 0) $"{failures} package consumers failed; see {directory}/results.json"
     printfn "Passed %d isolated %s consumers" results.Count mode
 
-// Public dependency regression: an erased binding can compile even when a package
-// omits the source Fable needs for ordinary inline helpers. Test that separately.
-let checkSupport supportFeed =
-    let label = if Option.isSome supportFeed then "candidate-support" else "public-support"
-    let directory = Path.Combine(output, label)
+// Exercise the erased keys and indexers consumed by CloudEdge bindings. The
+// separate upstream-helper repro covers APIs these bindings do not call.
+let checkSupport () =
+    let directory = Path.Combine(output, "public-support")
     if Directory.Exists directory then Directory.Delete(directory, true)
     mkdir directory
-    writeNuGetConfig (Path.Combine(directory, "NuGet.Config")) (Path.Combine(directory, "cache")) false supportFeed
+    writeNuGetConfig (Path.Combine(directory, "NuGet.Config")) (Path.Combine(directory, "cache")) false
     let tool = installFable directory
-    for file in ["Smoke.fs"; "UpstreamHelpers.fs"] do
+    for file in ["Smoke.fs"; "check.mjs"] do
         copyFile (Path.Combine(root, "tests/SupportPackage", file)) (Path.Combine(directory, file))
     let version = config.PublicDependencies["Xantham.Fable.Core"]
     let tsVersion = config.PublicDependencies["Xantham.Fable.Core.TS"]
@@ -139,15 +137,15 @@ let checkSupport supportFeed =
         xml "PropertyGroup" [] [valueElement "TargetFramework" "net8.0"]
         xml "ItemGroup" [] [
             xml "Compile" ["Include", "Smoke.fs"] []
-            xml "Compile" ["Include", "UpstreamHelpers.fs"] []
             xml "PackageReference" ["Include", "Fable.Core"; "Version", "5.2.0"] []
             xml "PackageReference" ["Include", "Xantham.Fable.Core"; "Version", $"[{version}]"] []
             xml "PackageReference" ["Include", "Xantham.Fable.Core.TS"; "Version", $"[{tsVersion}]"] []
         ]
     ] |> saveXml project
     run "dotnet" ["build"; project; "--nologo"] (Path.Combine(directory, "logs/build.log"))
-    run tool [project; "--outDir"; Path.Combine(directory, "js")] (Path.Combine(directory, "logs/fable.log"))
-    printfn "%s %s builds and emits through Fable" label version
+    run tool [project; "--outDir"; Path.Combine(directory, "fable-out")] (Path.Combine(directory, "logs/fable.log"))
+    run "node" [Path.Combine(directory, "check.mjs")] (Path.Combine(directory, "logs/runtime.log"))
+    printfn "Public support %s builds, emits through Fable and passes binding runtime assertions" version
 
 let normalized (text: string) =
     text.Replace("\r\n", "\n").Split('\n') |> Array.map _.TrimEnd() |> Array.skipWhile String.IsNullOrWhiteSpace |> Array.rev |> Array.skipWhile String.IsNullOrWhiteSpace |> Array.rev

tools/NuGetRelease/Packages.fs

@@ -148,14 +148,13 @@ let verify (projects: Package array) =
     Array.iter2 (fun a b -> ensure (a.Id = b.Id && a.Version = b.Version && a.File = b.File && a.Sha256 = b.Sha256) $"Candidate differs from manifest: {a.Id}") actual expected
     printfn "Verified %d packages and manifest hashes" actual.Length
 
-let pack jobs supportFeed (projects: Package array) =
+let pack jobs (projects: Package array) =
     ensure (jobs > 0) "The build process count must be positive"
     mkdir feed
     let restoreConfig = Path.Combine(output, "NuGet.Config")
-    writeNuGetConfig restoreConfig (Path.Combine(output, "cache")) true supportFeed
-    for project in projects do
-        let cached = Path.Combine(output, "cache", project.Id.ToLowerInvariant(), config.Version)
-        if Directory.Exists cached then Directory.Delete(cached, true)
+    let cache = Path.Combine(output, "cache")
+    if Directory.Exists cache then Directory.Delete(cache, true)
+    writeNuGetConfig restoreConfig cache true
     let commit = capture "git" ["rev-parse"; "HEAD"]
     let logDirectory = Path.Combine(output, "pack-logs")
     mkdir logDirectory