@valbuild/shared 0.145.0 → 0.146.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @valbuild/shared
 
+## 0.146.0
+
+### Minor Changes
+
+- [#861](https://github.com/valbuild/val/pull/861) [`89b0fa8`](https://github.com/valbuild/val/commit/89b0fa82a3ae0d8ccd5d0282c1034f1f40cc4e26) Thanks [@freekh](https://github.com/freekh)! - Proposals can be brought up to date with the site, like a pull request.
+
+  - **Update from the site** merges what was published on the site since a proposal started into the proposal, field by field. Where the site and the proposal changed the same field, the Publish dialog shows both and asks which to keep.
+  - **With code:** a proposal that changes code, or a site whose code changed since the proposal started, is updated too. The Studio runs each version's schemas in the tab, and the merged code is built before it can be published.
+  - Publish offers **Update from the site** whenever the site has moved under the proposal.
+
+- [#864](https://github.com/valbuild/val/pull/864) [`f0c7d27`](https://github.com/valbuild/val/commit/f0c7d27846c21f81ff6ce79c579185150bc0d063) Thanks [@freekh](https://github.com/freekh)! - Patch groups are removed. **Publish** now publishes every pending change, and
+  the Review list shows everyone's pending changes in one list. To keep changes
+  out of a publish, move them to a proposal.
+
+  Draft reads no longer send `own_patch_groups_only`, `patch_id` or
+  `include_patch_groups`, and the server no longer has the patch-group routes or
+  fields. A content host that still sends them is fine: they are ignored.
+
+## 0.145.1
+
+### Patch Changes
+
+- [#860](https://github.com/valbuild/val/pull/860) [`a45f595`](https://github.com/valbuild/val/commit/a45f595a5e20b009d4110bbef8ebdc08b2d731d7) Thanks [@freekh](https://github.com/freekh)! - `val publish` and the Studio now tell Val Build which version of the platform's React and TanStack a build was made against. If the platform is updated while a build is running — a project's CI can take several minutes — that build is no longer published onto a platform it was never checked against: the publish stops with a message saying the platform was updated and to build again, and the next build is checked against what it will run on. A build published with `val publish --artifacts` was made elsewhere and does not say, and publishes as before.
+
 ## 0.145.0
 
 ### Minor Changes

package/dist/declarations/src/internal/ApiRoutes.d.ts

@@ -21,21 +21,6 @@ export type PlanRefusalErrorT = z.infer<typeof PlanRefusalError>;
  * with the editor's cookie from another site.
  */
 export declare const VAL_STUDIO_HEADER = "x-val-studio";
-/**
- * A patch group: the set of patches one user has chosen to publish.
- *
- * Not a patch *set* — a patch set is computed from the schema and says which
- * patches must move together; a patch group is curated and says which ones this
- * user wants live. See `docs/independent-publish/PLAN.md`.
- */
-export declare const PatchGroup: z.ZodObject<{
-    patchGroupId: z.ZodString;
-    authorId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    publishedAt: z.ZodNullable<z.ZodString>;
-    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-}, z.core.$strip>;
-export type PatchGroupT = z.infer<typeof PatchGroup>;
 declare const cookies: z.ZodUnion<readonly [z.ZodLiteral<"val_session">, z.ZodLiteral<"val_enable">, z.ZodLiteral<"val_state">]>;
 type Cookies = z.infer<typeof cookies>;
 declare const enableCookieValue: z.ZodObject<{
@@ -447,13 +432,6 @@ export declare const Api: {
                     headCommitSha: z.ZodOptional<z.ZodString>;
                     headPatchId: z.ZodOptional<z.ZodNullable<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
                     headVersion: z.ZodOptional<z.ZodNumber>;
-                    patchGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        patchGroupId: z.ZodString;
-                        authorId: z.ZodNullable<z.ZodString>;
-                        createdAt: z.ZodString;
-                        publishedAt: z.ZodNullable<z.ZodString>;
-                        patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    }, z.core.$strip>>>;
                     commits: z.ZodArray<z.ZodObject<{
                         commitSha: z.ZodString;
                         clientCommitSha: z.ZodNullable<z.ZodString>;
@@ -730,7 +708,6 @@ export declare const Api: {
                     id: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
                 };
                 body: z.ZodOptional<z.ZodObject<{
-                    unstagePatchIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
                     reportHeadVersion: z.ZodOptional<z.ZodLiteral<true>>;
                 }, z.core.$strip>>;
                 cookies: {
@@ -779,8 +756,6 @@ export declare const Api: {
                         patchId: z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>;
                         patch: z.ZodAny;
                     }, z.core.$strip>>;
-                    patchGroupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    withPatchIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
                 }, z.core.$strip>;
                 cookies: {
                     val_session: z.ZodOptional<z.ZodString>;
@@ -827,7 +802,6 @@ export declare const Api: {
                         type: z.ZodLiteral<"patch">;
                         patchId: z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>;
                     }, z.core.$strip>]>;
-                    patchGroupId: z.ZodOptional<z.ZodString>;
                     headVersion: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
@@ -841,7 +815,6 @@ export declare const Api: {
                         type: z.ZodLiteral<"patch">;
                         patchId: z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>;
                     }, z.core.$strip>]>;
-                    patchGroupId: z.ZodOptional<z.ZodString>;
                     headVersion: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>;
             }, z.core.$strip>]>;
@@ -851,15 +824,6 @@ export declare const Api: {
                 query: {
                     patch_id: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
                     exclude_patch_ops: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
-                    /**
-                     * Include the patch group annotation in the answer.
-                     *
-                     * Off by default because the client CHUNKS this request — a long
-                     * chain is several round trips — and the groups are a property of the
-                     * branch, identical in every chunk. Asking on each one is N identical
-                     * lookups against the content API to learn the same thing.
-                     */
-                    include_patch_groups: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                 };
                 cookies: {
                     val_session: z.ZodOptional<z.ZodString>;
@@ -934,15 +898,7 @@ export declare const Api: {
                         appliedAt: z.ZodNullable<z.ZodObject<{
                             commitSha: z.ZodString;
                         }, z.core.$strip>>;
-                        patchGroupIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     }, z.core.$strip>>;
-                    patchGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        patchGroupId: z.ZodString;
-                        authorId: z.ZodNullable<z.ZodString>;
-                        createdAt: z.ZodString;
-                        publishedAt: z.ZodNullable<z.ZodString>;
-                        patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    }, z.core.$strip>>>;
                     baseSha: z.ZodString;
                     error: z.ZodOptional<z.ZodObject<{
                         message: z.ZodString;
@@ -954,88 +910,6 @@ export declare const Api: {
             }, z.core.$strip>]>;
         };
     };
-    "/patch-groups/~/patches": {
-        PUT: {
-            req: {
-                body: z.ZodObject<{
-                    patchGroupId: z.ZodOptional<z.ZodString>;
-                    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    withPatchIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
-                }, z.core.$strip>;
-                cookies: {
-                    val_session: z.ZodOptional<z.ZodString>;
-                };
-            };
-            res: z.ZodUnion<readonly [z.ZodObject<{
-                status: z.ZodLiteral<401>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<403>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<409>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<500>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<200>;
-                json: z.ZodObject<{
-                    patchGroupId: z.ZodNullable<z.ZodString>;
-                    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    headVersion: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>;
-            }, z.core.$strip>]>;
-        };
-        DELETE: {
-            req: {
-                body: z.ZodObject<{
-                    patchGroupId: z.ZodOptional<z.ZodString>;
-                    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    withPatchIds: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
-                }, z.core.$strip>;
-                cookies: {
-                    val_session: z.ZodOptional<z.ZodString>;
-                };
-            };
-            res: z.ZodUnion<readonly [z.ZodObject<{
-                status: z.ZodLiteral<401>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<403>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<409>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<500>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<200>;
-                json: z.ZodObject<{
-                    patchGroupId: z.ZodNullable<z.ZodString>;
-                    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    headVersion: z.ZodOptional<z.ZodNumber>;
-                }, z.core.$strip>;
-            }, z.core.$strip>]>;
-        };
-    };
     "/schema": {
         GET: {
             req: {
@@ -1083,33 +957,6 @@ export declare const Api: {
                     validate_binary_files: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                     exclude_patches: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                     apply_patches: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
-                    /**
-                     * Apply ONLY these patches, rather than everything pending.
-                     *
-                     * This is what makes a draft-mode render match the caller's staged
-                     * view. Without it `/sources/~` replays every pending patch on the
-                     * branch, so a server-rendered preview shows other people's
-                     * unpublished work — the one thing independent publish is for.
-                     *
-                     * Omitted means everything pending, which is the behaviour every
-                     * existing caller has and must keep. An EMPTY array is a different
-                     * answer and is honoured as one: a group holding nothing renders
-                     * base.
-                     */
-                    patch_id: z.ZodOptional<z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>>;
-                    /**
-                     * Apply only the patches in the CALLER'S OWN patch groups.
-                     *
-                     * The server resolves them from the session, so a draft render does
-                     * not have to know its own group ids — which it cannot, since it has
-                     * no client state. This is what makes `fetchVal` in draft mode show
-                     * the person their own staged work rather than everybody's.
-                     *
-                     * Ignored when `patch_id` is given: an explicit list is a caller that
-                     * already knows what it wants, and silently intersecting the two
-                     * would make the narrower one invisible.
-                     */
-                    own_patch_groups_only: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                 };
                 cookies: {
                     val_session: z.ZodOptional<z.ZodString>;
@@ -1306,7 +1153,6 @@ export declare const Api: {
                 body: z.ZodObject<{
                     message: z.ZodOptional<z.ZodString>;
                     patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
-                    patchGroupId: z.ZodOptional<z.ZodString>;
                     expectedHeadCommitSha: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>;
                 cookies: {
@@ -1333,11 +1179,6 @@ export declare const Api: {
                     }, z.core.$strip>>>;
                     headVersion: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<403>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<500>;
                 json: z.ZodObject<{
@@ -1359,9 +1200,6 @@ export declare const Api: {
                 }, z.core.$strip>, z.ZodObject<{
                     message: z.ZodString;
                     headMoved: z.ZodLiteral<true>;
-                }, z.core.$strip>, z.ZodObject<{
-                    message: z.ZodString;
-                    patchGroupPublished: z.ZodLiteral<true>;
                 }, z.core.$strip>]>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<400>;
@@ -1814,15 +1652,6 @@ export declare const Api: {
                     offset: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>>, z.ZodTransform<number, string>>>;
                     limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>>, z.ZodTransform<number, string>>>;
                     apply_patches: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
-                    /**
-                     * The caller's own staged work, and nobody else's.
-                     *
-                     * The same flag `/sources/~` takes, and for the same reason — a draft
-                     * page renders both, so a scoped module beside an unscoped
-                     * `jsonValues` entry showed one person's view and everybody's pending
-                     * work on the same screen.
-                     */
-                    own_patch_groups_only: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string, string[]>> & z.ZodType<"true" | "false", string[], z.core.$ZodTypeInternals<"true" | "false", string[]>>, z.ZodTransform<boolean, "true" | "false">>>;
                 };
                 cookies: {
                     [VAL_SESSION_COOKIE]: z.ZodOptional<z.ZodString>;

package/dist/declarations/src/internal/chainHead.d.ts

@@ -5,13 +5,11 @@ import type { PatchId } from "@valbuild/core";
  *
  * The head the server REPORTS (`headPatchId`) when it reports one, and not the
  * last patch it listed. The list — `/applicable/patches`, and `/stat` on top of
- * it — leaves out patches the running deployment already contains, and since
- * patch groups a publish can ship later patches while an earlier one stays
- * pending (another author's change that nets to nothing can never be published
- * at all). The last listed id is then behind the head for good, and the content
- * service accepts a write only on the head, so every save naming it is refused
- * — and a re-sync returns the same list. What fixed it in the Studio before
- * this existed was discarding the other author's change.
+ * it — leaves out patches the running deployment already contains, and a
+ * publish can ship later patches while an earlier one stays pending (a failed
+ * publish holds its changes back). The last listed id is then behind the head
+ * for good, and the content service accepts a write only on the head, so every
+ * save naming it is refused — and a re-sync returns the same list.
  *
  * `null` is a REPORTED empty chain, not "unknown". `undefined` is a server
  * that reports no head (`fs` mode, which ignores the parent anyway, or a

package/dist/declarations/src/internal/index.d.ts

@@ -37,3 +37,6 @@ export * from "./search/sourcePath.js";
 export * from "./theme/accentRamp.js";
 export * from "./publish/contentApi.js";
 export * from "./publish/protocol.js";
+export * from "./patchSets/PatchSets.js";
+export * from "./patchSets/schemaTypesOfPath.js";
+export * from "./proposalMerge/trees.js";

package/dist/declarations/src/internal/patchSets/PatchSets.d.ts

@@ -0,0 +1,75 @@
+import { ModuleFilePath, PatchId, SerializedSchema } from "@valbuild/core";
+import { Operation } from "@valbuild/core/patch";
+type AuthorId = string;
+type IsoDateString = string;
+export type PatchMetadata = {
+    patchId: PatchId;
+    patchPath: PatchPath;
+    opType: Operation["op"];
+    schemaTypes: Array<SerializedSchema["type"]>;
+    author: AuthorId | null;
+    createdAt: IsoDateString;
+};
+export type PatchSetMetadata = {
+    moduleFilePath: ModuleFilePath;
+    patchPath: PatchPath;
+    patches: PatchMetadata[];
+    authors: AuthorId[];
+    opTypes: Operation["op"][];
+    schemaTypes: Array<SerializedSchema["type"]>;
+    lastUpdated: IsoDateString;
+    lastUpdatedBy: AuthorId | null;
+};
+/**
+ * A patch set is a set of patches that are non-independent of each other. This is useful for example when we want to apply a set of patches atomically.
+ * A patch set is identified by a module file path and a json patch path delimited by a '?' character. We call this the patch set path. Example: /file/name.val.ts?/path/to/patch
+ *
+ *
+ * NOTE: the order of patch sets is always newest first. This is because the UX always shows the newest patches first.
+ */
+export type SerializedPatchSet = PatchSetMetadata[];
+type PatchPath = string[];
+/**
+ * Is `inner` strictly nested inside the patch set `outer`?
+ *
+ * A plain `inner.startsWith(outer)` is not enough, and the difference is not
+ * cosmetic. The file part of a key is terminated by the '?' delimiter, but the
+ * segments of the patch path are not terminated by anything, so a raw prefix
+ * test also matches siblings whose *name* merely starts with the same
+ * characters: '/p.val.ts?foobar/title' starts with '/p.val.ts?foo', so removing
+ * record key "foo" and retitling record key "foobar" would be merged into one
+ * patch set.
+ *
+ * That used to only over-group two unrelated changes in the compare view. Now
+ * that patch sets decide what moves between branches as one (whole patch sets,
+ * as `changesToMove` moves them), it means moving one key silently moves its
+ * similarly-named sibling — so the boundary has to be
+ * checked explicitly: '?' when `outer` is a bare module file path, '/' when it
+ * already has a patch path.
+ */
+export declare function isInsidePatchSetPath(inner: string, outer: string): boolean;
+export declare class PatchSets {
+    private insertedPatches;
+    private patchSetMetadata;
+    private orderedInsertKeys;
+    constructor();
+    reset(): void;
+    getInsertedPatches(): Set<PatchId>;
+    private insertPath;
+    /**
+     * Insert a whole patch.
+     *
+     * Takes the patch rather than one op because the de-duplication below is
+     * per-*patch*: a patch is either known to this instance or it is not. When this
+     * took a single op, callers looped and every call after the first hit the
+     * `insertedPatches` guard and returned — so only a patch's first op ever reached
+     * a patch set. A patch that touched two places (a `move`, or a `file` op sitting
+     * before its source op) was therefore mis-grouped, which is invisible in the
+     * compare view but decides what moves as one.
+     */
+    insert(moduleFilePath: ModuleFilePath, schema: SerializedSchema | undefined, patch: Operation[], patchId: PatchId, createdAt: IsoDateString, author: AuthorId | null): void;
+    private insertOp;
+    isInserted(patchId: PatchId): boolean;
+    serialize(): SerializedPatchSet;
+}
+export {};

package/dist/declarations/src/internal/patchSets/schemaTypesOfPath.d.ts

@@ -0,0 +1,5 @@
+import { SerializedSchema } from "@valbuild/core";
+/**
+ * This functions returns all the possible schema types of a given module path.
+ */
+export declare function schemaTypesOfPath(schema: SerializedSchema, patchPath?: string[]): Set<SerializedSchema["type"]>;

package/dist/declarations/src/internal/proposalMerge/trees.d.ts

@@ -0,0 +1,56 @@
+import type { ModuleFilePath, Schema, SelectorSource, SerializedSchema } from "@valbuild/core";
+import type { JSONValue } from "@valbuild/core/patch";
+/**
+ * Update from the site, for a proposal with code (valbuild/home
+ * `docs/hosted-publishing.md` step 8.2, slice 1b): what content hands over,
+ * what the builder tab makes of it, and what Val's server reads -- one
+ * definition of each for the three.
+ */
+/** Content a schema does not allow, by path in the module. */
+export type SchemaError = {
+    path: string[];
+    message: string;
+};
+/** Content's `merge-trees` answer. */
+export type MergeTrees = {
+    base: string | null;
+    siteHead: string | null;
+    proposalHead: string | null;
+    upToDate: boolean;
+    builds: {
+        base: string;
+        site: string;
+    };
+    trees: {
+        site: Record<string, string>;
+        base: Record<string, string | null>;
+        proposal: Record<string, string | null>;
+    };
+    modules: Record<string, {
+        base: string | null;
+        site: string | null;
+        proposal: string | null;
+    }>;
+    sources: Record<string, JSONValue>;
+};
+/** Which tree: where the proposal started, the site, or the proposal. */
+export type Side = "base" | "site" | "proposal";
+/** A module, as evaluating its tree in the tab gave it. */
+export type EvaluatedModule = {
+    schema: SerializedSchema;
+    /** The content its file's text holds. */
+    written: JSONValue;
+    /** The errors of the module's Source under this schema. */
+    errors: SchemaError[];
+};
+export type Evaluated = Record<ModuleFilePath, EvaluatedModule>;
+/** A side's files: the site's tree, the base's changes over it, the proposal's over that. */
+export declare function sideFiles(trees: MergeTrees, side: Side): Record<string, string>;
+/** A side's Source of a module, from content's index; `null` when it has none. */
+export declare function sideSource(trees: MergeTrees, side: Side, moduleFilePath: ModuleFilePath): JSONValue | null;
+/**
+ * What a schema reports about this content, without the errors the server
+ * fixes on its own (those with `fixes`): run on the schema instance that
+ * evaluating the module made, so custom rules take part.
+ */
+export declare function schemaErrorsOf(schema: Schema<SelectorSource>, moduleFilePath: ModuleFilePath, source: JSONValue | undefined): SchemaError[];

package/dist/declarations/src/internal/publish/contentApi.d.ts

@@ -50,9 +50,11 @@ export type ContentPublishApi = {
      *
      * ## What is deliberately not here
      *
-     * No loader URL, no `vendorRev`, no `x-platform-project`. This service holds
-     * the operator relationship with the build platform and calls it; a publisher
-     * talks to this API and nothing else. The one exception is the presigned
+     * No loader URL, no `x-platform-project`. This service holds the operator
+     * relationship with the build platform and calls it; a publisher talks to
+     * this API and nothing else. A publisher does say which base layer it built
+     * against (`baseRev` below) -- a fact about its build, which this service
+     * forwards -- but never addresses the platform itself. The one exception is the presigned
      * upload URL, which points at object storage -- bytes do not travel through
      * here.
      *
@@ -73,6 +75,18 @@ export type ContentPublishApi = {
                 branch: string | null;
                 /** Which dependency layer this was built against, sent or not. */
                 layerRev: string | null;
+                /**
+                 * Which BASE layer -- the platform's React and TanStack -- this was
+                 * built against: `base.rev` of the build target the build used.
+                 *
+                 * Content forwards it to the build platform as the build's own, and
+                 * the platform refuses a new build whose base layer it no longer
+                 * serves: one deployed while the build ran, which the build's layer
+                 * was never checked against. Left out when it is not known -- a build
+                 * made elsewhere and published with `--artifacts` -- which publishes
+                 * as every build did before.
+                 */
+                baseRev?: string | null;
                 /**
                  * Whether the app links its own CSS.
                  *
@@ -369,10 +383,6 @@ export type ContentPublishApi = {
     };
     "/publish-jobs/:jobId/discard": {
         POST: {
-            /** The forward closure, as `DELETE /patches` takes it. */
-            body: {
-                unstagePatchIds?: string[];
-            };
             /** Changes it could not discard: another job in flight holds them. */
             res: {
                 stillHeld: string[];

package/dist/declarations/src/internal/publish/protocol.d.ts

@@ -88,6 +88,11 @@ declare const buildTargetResponse: z.ZodObject<{
             flightServer: z.ZodString;
             serverFnBase: z.ZodString;
         }, z.core.$strip>;
+        pins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        exports: z.ZodOptional<z.ZodObject<{
+            worker: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+            browser: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     project: z.ZodObject<{
         rev: z.ZodNullable<z.ZodString>;
@@ -177,6 +182,11 @@ declare const updateTargetResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 flightServer: z.ZodString;
                 serverFnBase: z.ZodString;
             }, z.core.$strip>;
+            pins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            exports: z.ZodOptional<z.ZodObject<{
+                worker: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+                browser: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
         project: z.ZodObject<{
             rev: z.ZodNullable<z.ZodString>;

package/dist/declarations/src/internal/server/requestScopedMemo.d.ts

@@ -6,14 +6,16 @@
  * byte-identical each time, because the query and the session are fixed for the
  * length of a request. This is what makes the second and third call free.
  *
- * ## Why the scope is the REQUEST and can never be wider
- *
- * The memoised response is `own_patch_groups_only: true` — it contains the
- * CALLER'S OWN unpublished work, resolved from their session cookie. A memo
- * that outlived the request would serve one author's staged edits to the next
- * visitor, which is the exact failure `own_patch_groups_only` exists to
- * prevent, and it would be invisible: the draft would simply render somebody
- * else's half-finished sentence.
+ * ## Why the scope is the REQUEST
+ *
+ * The memoised response is a DRAFT -- unpublished work, read with the caller's
+ * session cookie. Every caller allowed to read drafts gets the same draft (patch
+ * groups, which made it per author, are gone), but whether a caller is allowed
+ * at all is decided per session. A memo that outlived the request would hand
+ * the draft to the next visitor without asking, and it would be invisible: the
+ * page would simply render somebody's half-finished sentence. Sharing it across
+ * requests is possible now, keyed on the chain's head, and would be its own
+ * measured change.
  *
  * So this module holds NO state of its own. The caller supplies the box, and
  * the box has to come from something the framework already scopes to the