@valbuild/shared 0.136.0 → 0.136.2

package/internal/dist/valbuild-shared-internal.esm.js

@@ -1,6 +1,6 @@
 import { Internal, CODE_LANGUAGES, resolveSettingsModule, missingDeclaredKeys, localeOfValue, discriminatedUnionBranchOf, DEFAULT_COLOR_FORMAT, declaredKeySetOf } from '@valbuild/core';
-import { _ as _createForOfIteratorHelper, o as _objectSpread2, q as _arrayLikeToArray, r as _unsupportedIterableToArray, s as _typeof, t as _defineProperty } from '../../dist/getSitemapTree-878d3888.esm.js';
-export { D as DEFAULT_CANVAS_SELECTION, e as DEFAULT_CANVAS_SELECTION_SOFT, b as VAL_AI_SESSION_STORAGE_KEY, d as VAL_CANVAS_MESSAGE, c as VAL_CANVAS_PARAM, V as VAL_CONFIG_SESSION_STORAGE_KEY, a as VAL_THEME_SESSION_STORAGE_KEY, h as getNextAppRouterSourceFolder, m as getPageRouterSitemapTree, k as getPageRouterSourceFolder, n as getPatternFromModuleFilePath, j as getTanStackRouterSourceFolder, l as isTanStackRoutesFolder, g as isValCanvasFrame, i as isValCanvasPageMessage, f as isValCanvasStudioMessage, p as parseRoutePattern, w as withValCanvasParam } from '../../dist/getSitemapTree-878d3888.esm.js';
+import { _ as _createForOfIteratorHelper, o as _objectSpread2, q as _arrayLikeToArray, r as _unsupportedIterableToArray, s as _typeof, t as _defineProperty, u as _toPropertyKey } from '../../dist/getSitemapTree-6fcdf745.esm.js';
+export { D as DEFAULT_CANVAS_SELECTION, e as DEFAULT_CANVAS_SELECTION_SOFT, b as VAL_AI_SESSION_STORAGE_KEY, d as VAL_CANVAS_MESSAGE, c as VAL_CANVAS_PARAM, V as VAL_CONFIG_SESSION_STORAGE_KEY, a as VAL_THEME_SESSION_STORAGE_KEY, h as getNextAppRouterSourceFolder, m as getPageRouterSitemapTree, k as getPageRouterSourceFolder, n as getPatternFromModuleFilePath, j as getTanStackRouterSourceFolder, l as isTanStackRoutesFolder, g as isValCanvasFrame, i as isValCanvasPageMessage, f as isValCanvasStudioMessage, p as parseRoutePattern, w as withValCanvasParam } from '../../dist/getSitemapTree-6fcdf745.esm.js';
 import { z } from 'zod';
 import { fromError } from 'zod-validation-error';
 import FlexSearch from 'flexsearch';
@@ -654,6 +654,62 @@ var VAL_SESSION_COOKIE = Internal.VAL_SESSION_COOKIE;
 var VAL_STATE_COOKIE = Internal.VAL_STATE_COOKIE;
 var VAL_ENABLE_COOKIE_NAME = Internal.VAL_ENABLE_COOKIE_NAME;
 
+/**
+ * One value, computed once per REQUEST.
+ *
+ * `fetchVal` in draft mode reads the whole module tree out of `/sources/~`, and
+ * a page that calls it three times used to ask three times — the answer being
+ * 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.
+ *
+ * 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
+ * request — React's `cache()` in an RSC, a `WeakMap` keyed on the `Request` in
+ * TanStack Start. `null` means "no request scope available", and that is not an
+ * error: it falls back to computing every time, which is what the code did
+ * before this existed. Ineffective is a safe failure here; leaking is not.
+ *
+ * The `key` is the second half of that guarantee. It carries whatever the
+ * answer depends on — the session — so a box that somehow outlived its request,
+ * or is shared by two sessions, MISSES rather than serving the wrong draft.
+ *
+ * ## The promise is cached, not the value
+ *
+ * React renders siblings concurrently, so three `fetchVal` calls in one page
+ * are usually in flight at the same time rather than one after another.
+ * Caching the resolved value would dedupe none of them; caching the promise
+ * dedupes both orderings.
+ */
+
+/**
+ * Returns the memoised promise for `key`, computing it only on a miss.
+ *
+ * A rejection is memoised along with everything else, on purpose: one failed
+ * read per request is the same answer for every caller in it, and retrying it
+ * two more times only makes a broken draft slower to render.
+ */
+function memoizePerRequest(box, key, compute) {
+  if (box === null) {
+    return compute();
+  }
+  if (box.promise !== undefined && box.key === key) {
+    return box.promise;
+  }
+  var promise = compute();
+  box.key = key;
+  box.promise = promise;
+  return promise;
+}
+
 function _regeneratorDefine(e, r, n, t) {
   var i = Object.defineProperty;
   try {
@@ -1967,6 +2023,86 @@ var Api = {
     }
   },
   // This has a path which is like this: /upload/patches/:patchId/files. Example: /upload/patches/76b9237a-7712-4d60-88b4-d273e6d6fe18/files
+  /**
+   * The content service's publish API, reached through this deployment.
+   *
+   * A managed project is built in the Studio's own tab -- there is no host
+   * watching a repository to pick a commit up -- and what it builds then has to
+   * be published. The browser cannot do that itself: it holds a session cookie
+   * for this origin and no credential content would accept. So the publish
+   * conversation goes through here, exactly as patches already do.
+   *
+   * ## Deliberately not typed past this point
+   *
+   * No `res`, and a body this does not describe. The shapes belong to content,
+   * and they are already written down twice -- once in content's own `Api.ts`
+   * and once in the copy `@valbuild/cli` keeps beside its parser so the two can
+   * be diffed by eye. A third copy here would be a third thing to keep in step,
+   * and this layer has no decision to make that would need one: it authenticates
+   * the caller, swaps the credential, and carries status and body back verbatim.
+   * The Studio parses the answer with the same module the CLI does.
+   *
+   * That means this route answers with statuses the generic result type does not
+   * model -- a 409 when a publish has already gone live, for one. `/save` has
+   * always done the same; the dispatch boundary erases the type and the adapter
+   * sends what it is given.
+   *
+   * ## What it may reach
+   *
+   * The sub-path is content's, minus `/v1`: `/publish`, `/publish/{id}` and its
+   * three steps, and `/build-target`. `ValOpsHttp.publishApi` holds the allow
+   * list, beside the credential, because the browser chooses this path.
+   */
+  "/publish-api": {
+    GET: {
+      req: {
+        path: z.string().optional(),
+        cookies: {
+          val_session: z.string().optional()
+        }
+      },
+      /*
+       * Content's status and body, carried through.
+       *
+       * Permissive on purpose: describing the shapes here would be the third
+       * copy of a contract content owns, and this layer reads none of them. A
+       * body that is not JSON -- a gateway's HTML error page -- arrives as
+       * `{ message }` rather than throwing, because a publish failing is
+       * something the editor has to be told about in words.
+       */
+      res: z.object({
+        status: z.number(),
+        json: z.unknown()
+      })
+    },
+    POST: {
+      req: {
+        path: z.string().optional(),
+        /*
+         * Unknown, and passed through unread. Every field content accepts here
+         * would otherwise have to be declared -- and kept in step -- by a layer
+         * that never looks at one.
+         */
+        body: z.unknown().optional(),
+        cookies: {
+          val_session: z.string().optional()
+        }
+      },
+      /*
+       * Content's status and body, carried through.
+       *
+       * Permissive on purpose: describing the shapes here would be the third
+       * copy of a contract content owns, and this layer reads none of them. A
+       * body that is not JSON -- a gateway's HTML error page -- arrives as
+       * `{ message }` rather than throwing, because a publish failing is
+       * something the editor has to be told about in words.
+       */
+      res: z.object({
+        status: z.number(),
+        json: z.unknown()
+      })
+    }
+  },
   "/upload/patches": {
     POST: {
       req: {
@@ -2448,6 +2584,49 @@ var Api = {
            * server that predates this.
            */
           commitSha: z.string().optional(),
+          /**
+           * The source files this commit wrote, by path, for a MANAGED project.
+           *
+           * A managed project has nobody to deploy it, so the Studio builds
+           * the site in the tab -- and the build has to contain the text this
+           * commit just produced. Nothing else can give it that: the
+           * project's stored source is what the LAST build was made from, and
+           * turning patched Source back into `.val.ts` text happens here, on
+           * the server, not in a browser. `null` is a file the commit
+           * deleted.
+           *
+           * Absent for a connected project, whose host builds from the
+           * repository, and from a server that predates it.
+           */
+          sourceFiles: z.record(z.string(), z.string().nullable()).optional(),
+          /**
+           * The binary files this commit wrote -- an image uploaded in the
+           * Studio -- base64, by path, for a MANAGED project.
+           *
+           * The same reason as `sourceFiles`: the in-tab build publishes the
+           * site, and a file this commit added is in no earlier build. Local
+           * files only; a remote one is served from its own URL and was never
+           * part of a build. A deleted file is a `null` in `sourceFiles`, as
+           * it always was.
+           */
+          binaryFiles: z.record(z.string(), z.string()).optional(),
+          /**
+           * The branch this commit is on, for a MANAGED project -- the
+           * content service's word for it.
+           *
+           * The in-tab build has to name the branch it was made at, and its
+           * only other source is the `val.server.ts` the last build was
+           * wired with: a project cloned from a template seed has one wired
+           * at no commit, so without this its first publish is branchless
+           * and the loader refuses it.
+           */
+          branch: z.string().optional(),
+          /**
+           * Binary files this commit wrote whose bytes the server could not
+           * read back before committing. Named so the Studio refuses to build
+           * a site that would 404 them, rather than publishing it.
+           */
+          binaryFilesUnread: z.array(z.string()).optional(),
           /**
            * Unpublished changes the save threw away because they could not be
            * applied.
@@ -6797,4 +6976,340 @@ function resolvePairGround(ground, ramp) {
   return typeof ground === "number" ? ramp[ground] : ground;
 }
 
-export { AA_LARGE, AA_TEXT, Api, BRAND_CONTRAST_PAIRS, BinaryFileRef, CodeOptions, ColorOptions, DEFAULT_ERROR_MESSAGE, DateOptions, ENCODE_DEFAULTS, ENCODE_MIME_TYPE_OF, FileOptions, HistoricalCommit, HistoricalModule, HistoricalPatchSet, HistoryError, ImageEncodeOption, ImageOptions, JSONValue, JSON_ENTRIES_BATCH_MAX, ModuleComparison, NEVER_ENCODED, ParentRef$1 as ParentRef, Patch, PatchBlock, PatchGroup, PatchId, PatchJSON, RAMP_STEPS, RemirrorBr, RemirrorBulletList, RemirrorHeading, RemirrorImage, RemirrorJSON, RemirrorLinkMark, RemirrorListItem, RemirrorOrderedList, RemirrorParagraph, RemirrorText, RemirrorTextMark, RestoreVerdict, RichTextOptions, SCHEMA_SOURCE_FIXES, SerializedArraySchema, SerializedBooleanSchema, SerializedCodeSchema, SerializedColorSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedFileSchema, SerializedImageSchema, SerializedKeyOfSchema, SerializedLiteralSchema, SerializedLocaleSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedRecordSchema, SerializedRichTextSchema, SerializedRouteSchema, SerializedSchema, SerializedSettingsSchema, SerializedStringSchema, SerializedValViewSchema, SharedValConfig, VAL_ENABLE_COOKIE_NAME, VAL_GREEN_RAMP, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCommit, ValDeployment, accentRamp, buildDuplicatePatch, buildEmptyAtPathPatch, buildFileRefValue, buildImageGalleryPatch, buildRemoveImageGalleryEntryPatch, buildSearchIndex, checkCompatibility, chooseEncoded, concatModulePath, contrastRatio, createRegExpFromPattern, createSearchIndex, createValClient, declaredLocales, describeContainerAtPath, emptyOf, explainIncompatible, filterBlockingValidationErrors, filterRoutesByPatterns, findSimilar, fitWithin, flattenRichText, getErrorMessageFromUnknownJson, getFilenameFromRef, getInlineImgInfo, getKeyOfRecordAt, getRefParts, getRoutesOf, getRoutesWithModulePaths, getSourceAt, indexModule, isMimeTypeAccepted, isRemoteSchema, isSchemaSourceFixError, isSkippedSource, keyOfRecordPath, levenshtein, localeAt, newestCommitSha, partitionValidationErrors, performSearch, relativeLuminance, remirrorToRichTextSource, removeModule, resolveEncodeSettings, resolvePairGround, resolveSchemaSourceFixForError, resolveSchemaSourceFixes, resolveSerializedSchemaAtPath, richTextToRemirror, safeParsePatch, sourcePathOfChild, themeCustomProperties, toolNames, traverseSchemaSource, urlOf, validateRoutePatterns, withExtension };
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+
+function _possibleConstructorReturn(t, e) {
+  if (e && ("object" == typeof e || "function" == typeof e)) return e;
+  if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+  return _assertThisInitialized(t);
+}
+
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && _setPrototypeOf(t, e);
+}
+
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function (t) {
+    if (null === t || !_isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
+
+/**
+ * Reading what content answers.
+ *
+ * Every type here comes from `contentApi.ts`, which is a copy of the
+ * service's own `Api.ts` - so the shapes are not re-derived from what this end
+ * wishes it received, and a copy brought up to date fails to compile wherever
+ * this CLI has not caught up.
+ *
+ * The schemas are the runtime half, and they are needed as well as the types:
+ * what arrives is JSON over HTTP from a service that versions separately, so a
+ * type alone asserts a shape rather than checking one. Each schema is
+ * annotated with the copied type it must produce (`z.ZodType<DeclareResponse>`
+ * and so on), which is what ties the two halves together - a schema that drifts
+ * from the copy does not compile, and an answer that drifts from the schema
+ * does not parse. `ValOpsHttp` in `@valbuild/server` reads every other content
+ * route the same way.
+ *
+ * Nothing here is laxer than the copy. An optional field is optional because
+ * the service says so; making a required one optional here would hide exactly
+ * the drift this file exists to catch.
+ */
+
+/** An artifact, as it is declared: by key, by hash, by size. */
+
+/** Permission to write one artifact's bytes to object storage. */
+
+var publishState = z["enum"](["awaiting-artifacts", "ready", "verified", "live", "failed", "expired"]);
+var publishProblem = z.object({
+  code: z.string(),
+  message: z.string(),
+  hint: z.string().optional(),
+  keys: z.array(z.string()).optional()
+});
+var uploadSlot = z.object({
+  key: z.string(),
+  url: z.string(),
+  method: z.literal("PUT"),
+  headers: z.record(z.string(), z.string()),
+  expiresAt: z.string()
+});
+var declareResponse = z.object({
+  publishId: z.string(),
+  state: publishState,
+  project: z.object({
+    publicProjectId: z.string(),
+    siteUrl: z.string().nullable()
+  }),
+  uploads: z.array(uploadSlot),
+  have: z.array(z.string())
+});
+var artifactsResponse = z.object({
+  state: publishState,
+  problems: z.array(publishProblem)
+});
+var verifyResponse = z.object({
+  state: publishState,
+  ok: z["boolean"](),
+  previewUrl: z.string().nullable(),
+  problems: z.array(publishProblem)
+});
+var promoteResponse = z.object({
+  state: publishState,
+  url: z.string().nullable(),
+  commit: z.string().nullable()
+});
+var statusResponse = z.object({
+  publishId: z.string(),
+  state: publishState,
+  buildHash: z.string(),
+  missing: z.array(z.string()),
+  problems: z.array(publishProblem)
+});
+var publishTokenResponse = z.object({
+  token: z.string(),
+  expiresAt: z.string().nullable(),
+  publicProjectId: z.string(),
+  productionUrl: z.string().nullable()
+});
+
+/**
+ * Content answered, and the answer was not one this CLI can act on.
+ *
+ * Separate from a refusal, which is content saying no in a sentence meant for
+ * a person. This is two programs disagreeing - the copy in `contentApi.ts` and
+ * the service that has moved on from it - and the two want opposite things
+ * said about them.
+ */
+var PublishProtocolError = /*#__PURE__*/function (_Error) {
+  function PublishProtocolError(message) {
+    var _this;
+    _classCallCheck(this, PublishProtocolError);
+    _this = _callSuper(this, PublishProtocolError, [message]);
+    _this.name = "PublishProtocolError";
+    return _this;
+  }
+  _inherits(PublishProtocolError, _Error);
+  return _createClass(PublishProtocolError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var parseDeclare = function parseDeclare(body) {
+  return parse(declareResponse, body, "POST /v1/publish");
+};
+var parseArtifacts = function parseArtifacts(body) {
+  return parse(artifactsResponse, body, "POST /v1/publish/{id}/artifacts");
+};
+var parseVerify = function parseVerify(body) {
+  return parse(verifyResponse, body, "POST /v1/publish/{id}/verify");
+};
+var parsePromote = function parsePromote(body) {
+  return parse(promoteResponse, body, "POST /v1/publish/{id}/promote");
+};
+var parseStatus = function parseStatus(body) {
+  return parse(statusResponse, body, "GET /v1/publish/{id}");
+};
+var parsePublishToken = function parsePublishToken(body, call) {
+  return parse(publishTokenResponse, body, call);
+};
+
+/**
+ * What a build targets, and the project's files, as the Studio asks for them.
+ *
+ * Both are read through `/publish-api` rather than fetched from the loader,
+ * because a browser has neither the loader's address nor a credential it would
+ * accept. `fetchBuildTarget` in `@valbuild/tanstack-build` is the other half --
+ * same shape, a different caller, and it CASTS where this parses.
+ *
+ * Parsed rather than cast here because of what sits in between: a proxy, a
+ * gateway and a service boundary. An HTML error page cast to `BuildTarget`
+ * fails several layers down inside rolldown with a message about a module
+ * specifier, and the publish that follows would label a build against a layer
+ * that was never there.
+ *
+ * The TYPE is inferred from this schema instead of imported. `BuildTarget` is
+ * declared in `@valbuild/tanstack-build`, which has no zod and deliberately
+ * almost no dependencies -- it goes into a browser bundle -- and this package
+ * is imported by everything. The declarations are kept honest at the one place
+ * the value is used: it is passed straight into `buildUserApp({ target })`, so
+ * a drift between them is a compile error at that call rather than a runtime
+ * surprise.
+ */
+var buildTargetResponse = z.object({
+  base: z.object({
+    rev: z.string(),
+    shellRev: z.string(),
+    rscShellRev: z.string(),
+    modules: z.record(z.string(), z.string()),
+    rscModules: z.record(z.string(), z.string()),
+    paths: z.object({
+      baseFromProject: z.string(),
+      projectVendorDir: z.string(),
+      rscVendorBase: z.string(),
+      rscRuntimeSpecifier: z.string(),
+      rscRuntimePath: z.string(),
+      flightServer: z.string(),
+      serverFnBase: z.string()
+    })
+  }),
+  project: z.object({
+    rev: z.string().nullable(),
+    rsc: z["boolean"](),
+    modules: z.record(z.string(), z.string()),
+    css: z.record(z.string(), z.string()),
+    workerOnly: z.array(z.string())
+  })
+});
+/**
+ * `null` files is a real answer: a project that has never published.
+ *
+ * Distinguished from an empty record, which would be a project that published
+ * nothing -- and which a build would take as "no entry point" rather than as
+ * "there is nothing here yet".
+ */
+var projectSourceResponse = z.object({
+  files: z.record(z.string(), z.string()).nullable(),
+  /**
+   * The live build's `public/*` artifacts, by hash -- what a publisher with no
+   * checkout carries into its build so the site keeps its favicon and images.
+   *
+   * The loader stores public files PER BUILD, so a build that names none
+   * serves none. A publisher with a checkout has them on disk; the Studio has
+   * this. Re-declaring one costs nothing: content holds the bytes for the
+   * project already and asks for no upload.
+   *
+   * `null` when content cannot say -- the live build was not published through
+   * it -- and absent from a content service that predates it. A publisher
+   * must treat both as "unknown", never as "none": publishing on that guess
+   * deletes every public file the site has.
+   */
+  publicFiles: z.array(z.object({
+    key: z.string(),
+    sha256: z.string(),
+    bytes: z.number()["int"]().nonnegative()
+  })).nullable().optional(),
+  /**
+   * The URL paths the live build serves from `public/`, as the loader has
+   * them -- without the bytes' hashes.
+   *
+   * The fallback for when `publicFiles` is `null`: a build content has no
+   * record of, which is every project cloned from a template seed. A publisher
+   * running on the site's own origin can fetch these and build with them;
+   * after that publish content holds their hashes and `publicFiles` answers.
+   * `null` when the loader serves no build or does not say.
+   */
+  publicPaths: z.array(z.string()).nullable().optional()
+});
+var parseBuildTarget = function parseBuildTarget(body) {
+  return parse(buildTargetResponse, body, "GET /v1/build-target");
+};
+var parseProjectSource = function parseProjectSource(body) {
+  return parse(projectSourceResponse, body, "GET /v1/project-source");
+};
+
+/**
+ * The `details` of a refusal, when it carries a list of problems.
+ *
+ * Every non-2xx is `{ statusCode, message, details? }`, and the publish routes
+ * put `PublishProblem[]` in `details` - a declaration is answered with EVERY
+ * problem rather than the first, because finding them one round trip at a time
+ * is how a publish takes six attempts. Anything else in there is somebody
+ * else's `details` and is left to the caller's own message.
+ */
+function parseProblems(details) {
+  var parsed = z.array(publishProblem).safeParse(details);
+  return parsed.success ? parsed.data : [];
+}
+function parse(schema, body, call) {
+  var parsed = schema.safeParse(body);
+  if (!parsed.success) {
+    throw new PublishProtocolError("".concat(call, " answered with something this publisher cannot read: ").concat(fromError(parsed.error).toString()));
+  }
+  return parsed.data;
+}
+
+export { AA_LARGE, AA_TEXT, Api, BRAND_CONTRAST_PAIRS, BinaryFileRef, CodeOptions, ColorOptions, DEFAULT_ERROR_MESSAGE, DateOptions, ENCODE_DEFAULTS, ENCODE_MIME_TYPE_OF, FileOptions, HistoricalCommit, HistoricalModule, HistoricalPatchSet, HistoryError, ImageEncodeOption, ImageOptions, JSONValue, JSON_ENTRIES_BATCH_MAX, ModuleComparison, NEVER_ENCODED, ParentRef$1 as ParentRef, Patch, PatchBlock, PatchGroup, PatchId, PatchJSON, PublishProtocolError, RAMP_STEPS, RemirrorBr, RemirrorBulletList, RemirrorHeading, RemirrorImage, RemirrorJSON, RemirrorLinkMark, RemirrorListItem, RemirrorOrderedList, RemirrorParagraph, RemirrorText, RemirrorTextMark, RestoreVerdict, RichTextOptions, SCHEMA_SOURCE_FIXES, SerializedArraySchema, SerializedBooleanSchema, SerializedCodeSchema, SerializedColorSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedDiscriminatedUnionSchema, SerializedEnumSchema, SerializedFileSchema, SerializedImageSchema, SerializedKeyOfSchema, SerializedLiteralSchema, SerializedLocaleSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedRecordSchema, SerializedRichTextSchema, SerializedRouteSchema, SerializedSchema, SerializedSettingsSchema, SerializedStringSchema, SerializedValViewSchema, SharedValConfig, VAL_ENABLE_COOKIE_NAME, VAL_GREEN_RAMP, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCommit, ValDeployment, accentRamp, buildDuplicatePatch, buildEmptyAtPathPatch, buildFileRefValue, buildImageGalleryPatch, buildRemoveImageGalleryEntryPatch, buildSearchIndex, checkCompatibility, chooseEncoded, concatModulePath, contrastRatio, createRegExpFromPattern, createSearchIndex, createValClient, declaredLocales, describeContainerAtPath, emptyOf, explainIncompatible, filterBlockingValidationErrors, filterRoutesByPatterns, findSimilar, fitWithin, flattenRichText, getErrorMessageFromUnknownJson, getFilenameFromRef, getInlineImgInfo, getKeyOfRecordAt, getRefParts, getRoutesOf, getRoutesWithModulePaths, getSourceAt, indexModule, isMimeTypeAccepted, isRemoteSchema, isSchemaSourceFixError, isSkippedSource, keyOfRecordPath, levenshtein, localeAt, memoizePerRequest, newestCommitSha, parseArtifacts, parseBuildTarget, parseDeclare, parseProblems, parseProjectSource, parsePromote, parsePublishToken, parseStatus, parseVerify, partitionValidationErrors, performSearch, relativeLuminance, remirrorToRichTextSource, removeModule, resolveEncodeSettings, resolvePairGround, resolveSchemaSourceFixForError, resolveSchemaSourceFixes, resolveSerializedSchemaAtPath, richTextToRemirror, safeParsePatch, sourcePathOfChild, themeCustomProperties, toolNames, traverseSchemaSource, urlOf, validateRoutePatterns, withExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/shared",
-  "version": "0.136.0",
+  "version": "0.136.2",
   "private": false,
   "description": "Val shared types and utilities",
   "repository": {
@@ -37,7 +37,7 @@
     "flexsearch": "^0.8.212",
     "zod": "^4.4.3",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.136.0"
+    "@valbuild/core": "0.136.1"
   },
   "files": [
     "CHANGELOG.md",