@valbuild/shared 0.145.1 → 0.146.0

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

@@ -383,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/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

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

@@ -1,7 +1,7 @@
 import { Json } from "@valbuild/core";
-export declare const VAL_SESSION_COOKIE: "val_session";
-export declare const VAL_STATE_COOKIE: "val_state";
-export declare const VAL_ENABLE_COOKIE_NAME: "val_enable";
+export declare const VAL_SESSION_COOKIE: any;
+export declare const VAL_STATE_COOKIE: any;
+export declare const VAL_ENABLE_COOKIE_NAME: any;
 export type VAL_SESSION_COOKIE = typeof VAL_SESSION_COOKIE;
 export type VAL_STATE_COOKIE = typeof VAL_STATE_COOKIE;
 export type VAL_ENABLE_COOKIE_NAME = typeof VAL_ENABLE_COOKIE_NAME;

package/dist/declarations/src/internal/zod/History.d.ts

@@ -65,8 +65,8 @@ export declare const BinaryFileRef: z.ZodObject<{
 export type BinaryFileRef = z.infer<typeof BinaryFileRef>;
 export declare const HistoricalModule: z.ZodObject<{
     source: z.ZodNullable<z.ZodType<JSONValueT, unknown, z.core.$ZodTypeInternals<JSONValueT, unknown>>>;
-    schema: z.ZodNullable<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
-    patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
+    schema: z.ZodNullable<z.ZodType<SerializedSchemaT, unknown, z.core.$ZodTypeInternals<SerializedSchemaT, unknown>>>;
+    patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
     changedPaths: z.ZodArray<z.ZodString>;
     failures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"commit-not-found">;
@@ -110,8 +110,8 @@ export declare const HistoricalPatchSet: z.ZodObject<{
     }, z.core.$strip>;
     modules: z.ZodRecord<z.ZodString, z.ZodObject<{
         source: z.ZodNullable<z.ZodType<JSONValueT, unknown, z.core.$ZodTypeInternals<JSONValueT, unknown>>>;
-        schema: z.ZodNullable<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
-        patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
+        schema: z.ZodNullable<z.ZodType<SerializedSchemaT, unknown, z.core.$ZodTypeInternals<SerializedSchemaT, unknown>>>;
+        patchIds: z.ZodArray<z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>>;
         changedPaths: z.ZodArray<z.ZodString>;
         failures: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"commit-not-found">;
@@ -139,7 +139,7 @@ export declare const HistoricalPatchSet: z.ZodObject<{
         }, z.core.$strip>], "kind">>;
     }, z.core.$strip>>;
     patches: z.ZodArray<z.ZodObject<{
-        patchId: z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>;
+        patchId: z.ZodString & z.ZodType<PatchIdT, string, z.core.$ZodTypeInternals<PatchIdT, string>>;
         moduleFilePath: z.ZodString;
         patch: z.ZodUnknown;
         authorId: z.ZodNullable<z.ZodString>;

package/dist/declarations/src/internal/zod/Patch.d.ts

@@ -1,5 +1,4 @@
 import type { JSONValue as JSONValueT, PatchJSON as PatchJSONT, PatchBlock as PatchBlockT, ParentRef as ParentRefT } from "@valbuild/core/patch";
-import type { PatchId as PatchIdT } from "@valbuild/core";
 import { z } from "zod";
 /**
  * JSON, recursively — the shape of a Source over the wire.

package/dist/declarations/src/internal/zod/SerializedSchema.d.ts

@@ -83,7 +83,7 @@ export declare const SerializedSettingsSchema: z.ZodType<SerializedSettingsSchem
  */
 export declare const SerializedValViewSchema: z.ZodObject<{
     type: z.ZodLiteral<"view">;
-    moduleFilePath: z.ZodType<import("@valbuild/core").ModuleFilePath, unknown, z.core.$ZodTypeInternals<import("@valbuild/core").ModuleFilePath, unknown>>;
+    moduleFilePath: z.ZodType<ModuleFilePathT, unknown, z.core.$ZodTypeInternals<ModuleFilePathT, unknown>>;
     opt: z.ZodLiteral<false>;
     readonly: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;