@valbuild/shared 0.113.0 → 0.116.0

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

@@ -870,36 +870,6 @@ export declare const Api: {
             }, z.core.$strip>]>;
         };
     };
-    "/commit-summary": {
-        GET: {
-            req: {
-                query: {
-                    patch_id: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
-                };
-                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<400>;
-                json: z.ZodObject<{
-                    message: z.ZodString;
-                }, z.core.$strip>;
-            }, z.core.$strip>, z.ZodObject<{
-                status: z.ZodLiteral<200>;
-                json: z.ZodObject<{
-                    patchIds: z.ZodArray<z.ZodString & z.ZodType<import("@valbuild/core").PatchId, string, z.core.$ZodTypeInternals<import("@valbuild/core").PatchId, string>>>;
-                    baseSha: z.ZodString;
-                    commitSummary: z.ZodNullable<z.ZodString>;
-                }, z.core.$strip>;
-            }, z.core.$strip>]>;
-        };
-    };
     "/save": {
         POST: {
             req: {
@@ -1064,6 +1034,7 @@ export declare const Api: {
                 json: z.ZodObject<{
                     nonce: z.ZodString;
                     wsUrl: z.ZodString;
+                    providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<500>;

package/dist/declarations/src/internal/aiTools/aiImageToolPatches.d.ts

@@ -0,0 +1,60 @@
+import { type ImageMetadata, type SerializedSchema, type Source } from "@valbuild/core";
+import { Patch } from "../zod/Patch.js";
+import type { ToolName } from "./toolNames.js";
+export type CombinedImageMetadata = ImageMetadata;
+type GalleryArgs = {
+    filePath: string;
+    imageKey: string;
+    metadata: CombinedImageMetadata;
+};
+type RemoveGalleryArgs = {
+    filePath: string;
+};
+export type BuildResult = {
+    kind: "ok";
+    patch: Patch;
+} | {
+    kind: "wrong-tool";
+    suggestedTool: ToolName;
+    reason: string;
+} | {
+    kind: "error";
+    message: string;
+};
+export declare function buildFileRefValue(filePath: string, metadata: Record<string, unknown>): Record<string, unknown>;
+export declare function getSourceAt(source: Source | undefined, path: string[]): Source | undefined;
+export type ResolveResult = {
+    kind: "leaf";
+    schema: SerializedSchema;
+} | {
+    kind: "richtext";
+    schema: SerializedSchema;
+    remainingPath: string[];
+} | {
+    kind: "gallery-traversed";
+    schema: SerializedSchema;
+} | {
+    kind: "unresolved";
+};
+/**
+ * Walks `schema` along `path`, returning a structured result:
+ * - `leaf`: walked the full path; resolved schema at the end.
+ * - `richtext`: hit a richtext mid-walk; richtext is the resolved schema.
+ * - `gallery-traversed`: hit an `s.images()` record and walked past it (i.e. the
+ *   path tries to address an entry inside the gallery — a clue the AI should
+ *   have used the gallery tool instead).
+ * - `unresolved`: the path could not be walked.
+ */
+export declare function resolveSerializedSchemaAtPath(schema: SerializedSchema, path: string[]): ResolveResult;
+export type InlineImgInfo = {
+    kind: "not-allowed";
+} | {
+    kind: "allowed";
+    remote: boolean;
+};
+export declare function getInlineImgInfo(richtextSchema: SerializedSchema): InlineImgInfo;
+export declare function isRemoteSchema(schema: SerializedSchema): boolean;
+export declare function safeParsePatch(patch: unknown[]): BuildResult;
+export declare function buildImageGalleryPatch(args: GalleryArgs, moduleSchema: SerializedSchema): BuildResult;
+export declare function buildRemoveImageGalleryEntryPatch(args: RemoveGalleryArgs, moduleSchema: SerializedSchema, moduleSource: Source | undefined): BuildResult;
+export {};

package/dist/declarations/src/internal/aiTools/aiSourceToolPatches.d.ts

@@ -0,0 +1,44 @@
+import type { SerializedSchema, Source } from "@valbuild/core";
+import { type BuildResult } from "./aiImageToolPatches.js";
+export declare function buildDuplicatePatch(args: {
+    sourcePath: string[];
+    destinationPath: string[];
+}, moduleSchema: SerializedSchema, moduleSource: Source | undefined): BuildResult;
+export declare function buildEmptyAtPathPatch(args: {
+    destinationPath: string[];
+}, moduleSchema: SerializedSchema, moduleSource: Source | undefined): BuildResult;
+/**
+ * What kind of container a path points at.
+ *
+ * `gallery` and `richtext` are called out separately from `record`/`array`
+ * because the two callers disagree about them: `count_entries` can count either,
+ * `get_record_keys` documents that it refuses both.
+ */
+export type ContainerKind = "array" | "record" | "object" | "gallery" | "richtext";
+export type DescribeContainerResult = {
+    kind: "ok";
+    container: ContainerKind;
+    value: Source;
+} | {
+    kind: "error";
+    /**
+     * Whether the path is not there at all, or is there but holds something
+     * that has no entries.
+     *
+     * The distinction is not cosmetic: a caller that maps these onto its own
+     * error codes has to tell "go and look for this path" apart from "the
+     * path is right, its type is not", and only the second is worth a retry
+     * with a different tool.
+     */
+    reason: "missing" | "not-a-container";
+    message: string;
+};
+/**
+ * Classifies the value at `path` using the SCHEMA, not just its runtime shape.
+ *
+ * The runtime shape is not enough: an `s.image()`/`s.file()` source, a richtext
+ * node and a union variant are all plain objects at runtime, so classifying by
+ * `typeof` alone let `get_record_keys` list a file ref's `_ref`/`_type` internals
+ * or a richtext node's `tag`/`children` as if they were record keys.
+ */
+export declare function describeContainerAtPath(moduleSchema: SerializedSchema, moduleSource: Source | undefined, path: string[]): DescribeContainerResult;

package/dist/declarations/src/internal/aiTools/toolNames.d.ts

@@ -0,0 +1,2 @@
+export declare const toolNames: readonly ["get_all_schema", "get_source", "search_content", "validate_content", "create_patch", "add_session_image_to_gallery", "remove_image_gallery_entry", "navigate_to", "get_current_context", "get_patches", "get_source_path_from_route", "set_session_name", "show_compare_view", "ask_user_question", "duplicate_source", "empty_at_path", "count_entries", "get_record_keys"];
+export type ToolName = (typeof toolNames)[number];

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

@@ -0,0 +1,2 @@
+import { SerializedSchema, Json } from "@valbuild/core";
+export declare function emptyOf(schema: SerializedSchema): Json;

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

@@ -16,3 +16,9 @@ export * from "./resolveSchemaSourceFixes.js";
 export * from "./getErrorMessageFromUnknownJson.js";
 export * from "./zod/SerializedSchema.js";
 export * from "./valCanvasProtocol.js";
+export * from "./emptyOf.js";
+export * from "./aiTools/toolNames.js";
+export * from "./aiTools/aiImageToolPatches.js";
+export * from "./aiTools/aiSourceToolPatches.js";
+export * from "./validation/partitionValidationErrors.js";
+export * from "./validation/blockingValidationErrors.js";

package/dist/declarations/src/internal/validation/blockingValidationErrors.d.ts

@@ -0,0 +1,26 @@
+import { type Json, type ModuleFilePath, type SerializedSchema, type SourcePath, type ValidationError } from "@valbuild/core";
+/**
+ * The errors a user must actually act on.
+ *
+ * Two passes stand between a schema's complaint and something worth blocking a
+ * publish for:
+ *
+ * - `resolveSchemaSourceFixes` resolves the CROSS-MODULE fixes —
+ *   `keyof:check-keys` and `router:check-route` — against the live schema and
+ *   source. Unresolved, those arrive as "This error should typically be
+ *   processed by Val internally. Seeing this error most likely means you have a
+ *   Val version mismatch", which is not something a user can do anything with.
+ * - `partitionValidationErrors` drops the fixes the SERVER applies on save:
+ *   image and file metadata, remote files, gallery directory checks. Blocking on
+ *   those would refuse a publish for something the publish itself repairs.
+ *
+ * ## Everything that gates on validation must use this
+ *
+ * That is the whole reason it lives in `validation/` rather than beside one of
+ * its callers. There are three: the errors a field shows, the AI flow's check on
+ * a proposed patch, and — the one that bites — `system.publish`. A publish gate
+ * reading raw errors refuses on `router:check-route` for every route module in
+ * the project, which is a Save button that does nothing and says
+ * "validation-errors" with no error visible anywhere on screen.
+ */
+export declare function filterBlockingValidationErrors(validationErrors: Record<SourcePath, ValidationError[]>, schemas: Record<ModuleFilePath, SerializedSchema> | null, sources: Record<ModuleFilePath, Json> | null): Record<SourcePath, ValidationError[]>;

package/dist/declarations/src/internal/validation/partitionValidationErrors.d.ts

@@ -0,0 +1,27 @@
+import type { SourcePath, ValidationError } from "@valbuild/core";
+/**
+ * Partition validation errors by whether the UI should surface them.
+ *
+ * `skipped` errors carry only fix codes the user can't (or shouldn't) act on
+ * in the browser:
+ *   - image/file metadata checks (need to read bytes from disk)
+ *   - remote upload/download/check (need a personal access token + network)
+ *   - gallery directory uniqueness + untracked-files checks (need fs traversal)
+ *
+ * The server (ValOps + createFixPatch) resolves all of these automatically on
+ * save, and the CLI's `runValidation` does the same. So the user never needs
+ * to see them in the studio — but we keep them in the `skipped` partition,
+ * not dropped, so we can later surface a "N fixes pending — saving will
+ * repair them" badge or wire up an explicit "fix all" affordance without
+ * having to plumb the data back in.
+ *
+ * `keyof:check-keys` and `router:check-route` are surfaced if they reach
+ * this function — they're meant to be resolved upfront by the shared
+ * `resolveSchemaSourceFixes`. A remnant here means resolution didn't run
+ * for some reason; the user-facing "Invalid key/route" message is more
+ * useful than silent hiding.
+ */
+export declare function partitionValidationErrors(validationErrors: Record<SourcePath, ValidationError[]>): {
+    surfaced: Record<SourcePath, ValidationError[]>;
+    skipped: Record<SourcePath, ValidationError[]>;
+};