@valbuild/shared 0.148.6 → 0.149.7

package/dist/createForOfIteratorHelper-3db5d737.esm.js

@@ -0,0 +1,121 @@
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+export { _typeof as _, _createForOfIteratorHelper as a, _objectSpread2 as b, _defineProperty as c, _toPropertyKey as d, _arrayLikeToArray as e, _unsupportedIterableToArray as f };

package/dist/createForOfIteratorHelper-90e6a8b6.cjs.prod.js

@@ -0,0 +1,129 @@
+'use strict';
+
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+exports._arrayLikeToArray = _arrayLikeToArray;
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._defineProperty = _defineProperty;
+exports._objectSpread2 = _objectSpread2;
+exports._toPropertyKey = _toPropertyKey;
+exports._typeof = _typeof;
+exports._unsupportedIterableToArray = _unsupportedIterableToArray;

package/dist/createForOfIteratorHelper-d86bb352.cjs.dev.js

@@ -0,0 +1,129 @@
+'use strict';
+
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+exports._arrayLikeToArray = _arrayLikeToArray;
+exports._createForOfIteratorHelper = _createForOfIteratorHelper;
+exports._defineProperty = _defineProperty;
+exports._objectSpread2 = _objectSpread2;
+exports._toPropertyKey = _toPropertyKey;
+exports._typeof = _typeof;
+exports._unsupportedIterableToArray = _unsupportedIterableToArray;

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

@@ -1846,7 +1846,7 @@ export declare const Api: {
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<200>;
-                body: z.ZodCustom<import("node:stream/web").ReadableStream<unknown>, import("node:stream/web").ReadableStream<unknown>>;
+                body: z.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>;
             }, z.core.$strip>]>;
         };
     };
@@ -1874,10 +1874,10 @@ export declare const Api: {
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<200>;
-                body: z.ZodCustom<import("node:stream/web").ReadableStream<unknown>, import("node:stream/web").ReadableStream<unknown>>;
+                body: z.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<206>;
-                body: z.ZodCustom<import("node:stream/web").ReadableStream<unknown>, import("node:stream/web").ReadableStream<unknown>>;
+                body: z.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>;
             }, z.core.$strip>, z.ZodObject<{
                 status: z.ZodLiteral<416>;
                 json: z.ZodObject<{

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

@@ -43,3 +43,4 @@ export * from "./patchSets/PatchSets.js";
 export * from "./patchSets/selectionClosure.js";
 export * from "./patchSets/schemaTypesOfPath.js";
 export * from "./proposalMerge/trees.js";
+export * from "./selfCheck.js";

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

@@ -0,0 +1,51 @@
+import { type Json, type ModuleFilePath, type ValModules } from "@valbuild/core";
+/**
+ * A Val checking a site with ITS OWN rules: the platform's upgrade page
+ * (valbuild/home `docs/plans/upgrades-v2.md`, piece E) calls this on the
+ * version an upgrade moves to, because only that version knows what it
+ * requires of the site's content.
+ *
+ * The page is home's and runs no Val code of its own. It finds this as
+ * `Internal.selfCheck` on the framework package in the site's own vendor
+ * layer -- the copy that made the site's schemas, since `val.config.ts`
+ * imports `initVal` from it -- and hands it the default export of the
+ * site's `val.modules.ts`, bundled. A Val from before this has no
+ * `selfCheck`, and the page says validation was not available.
+ *
+ * The answer is data the page shows and nothing else, so its shape is the
+ * contract: {@link SELF_CHECK_VERSION} names it, and an answer the page
+ * cannot read counts as a failed check there. Change the shape and the
+ * version goes up.
+ */
+export declare const SELF_CHECK_VERSION = 1;
+/** Content the site's schemas do not allow, or a module that would not load. */
+export type SelfCheckError = {
+    /** The module, or `null` for an entry of `val.modules.ts` that did not load. */
+    moduleFilePath: string | null;
+    /** Where in the module, as keys and indices; `[]` for the module itself. */
+    path: string[];
+    message: string;
+};
+export type SelfCheckResult = {
+    version: typeof SELF_CHECK_VERSION;
+    /** The `@valbuild/core` that checked. */
+    valVersion: string;
+    /** How many modules `val.modules.ts` names. */
+    modules: number;
+    /** What holds a publish back: the errors the Studio would show. */
+    errors: SelfCheckError[];
+    /**
+     * Errors Val repairs itself when the content is saved (an image's
+     * metadata, say), which hold nothing back. Counted, so the page can say so.
+     */
+    repairedOnSave: number;
+};
+export type SelfCheckOptions = {
+    /**
+     * The site's content for a module: what it holds now, with every published
+     * edit, rather than what its file's text held when the build was made.
+     * `null` or `undefined` checks the file's own content.
+     */
+    sourceOf?: (moduleFilePath: ModuleFilePath) => Json | null | undefined;
+};
+export declare function selfCheck(valModules: ValModules, options?: SelfCheckOptions): Promise<SelfCheckResult>;

package/dist/declarations/src/publish/buildProposal.d.ts

@@ -0,0 +1,106 @@
+import type { BuildTargetResponse } from "../internal/index.js";
+import type { StudioDeployResult } from "./runStudioDeploy.js";
+/** A proposal as content answers it, as far as a build reads it. */
+export type BuiltProposal = {
+    staged?: {
+        inputs: string | null;
+        buildRequired: boolean;
+    } | null;
+    built?: {
+        hash: string;
+        inputs?: string | null;
+    } | null;
+};
+/** The calls a build of a proposal makes. An error carries content's `status`. */
+export type ProposalBuildClient<P extends BuiltProposal> = {
+    /** Its files, and what is staged. */
+    files(name: string): Promise<{
+        files: Record<string, string | null>;
+        staged: {
+            inputs: string | null;
+            buildRequired: boolean;
+        };
+    }>;
+    /** What it builds on: its own layer, or the site's. */
+    buildTarget(name: string): Promise<{
+        target: BuildTargetResponse;
+        layer: "site" | "own";
+    }>;
+    serveBuild(name: string, build: {
+        publishId: string;
+        inputs: string;
+    }): Promise<P>;
+    get(name: string): Promise<P>;
+};
+/** What a build of the proposal came to. */
+export type ProposalBuildOutcome<P> = {
+    status: "built";
+    hash: string | null;
+    proposal: P;
+} | {
+    status: "nothing-staged";
+} | {
+    status: "already-built";
+    hash: string | null;
+} | {
+    status: "failed";
+    message: string;
+};
+/**
+ * Where a build of the proposal is, around the deploy: the deploy's own steps
+ * are the Studio's deploy state (`useStudioDeployState`), and these are the
+ * parts before and after it.
+ *
+ * - `reading`: the proposal's files and the target to build them on.
+ * - `deploying`: the deploy is running; its state says which step.
+ * - `serving`: content is putting the build up at the proposal's address.
+ * - `waiting`: that request did not come back -- a gateway gave up on it --
+ *   and content is asked until it says the proposal is built.
+ */
+export type ProposalBuildStep = {
+    kind: "reading";
+} | {
+    kind: "deploying";
+} | {
+    kind: "serving";
+    since: number;
+} | {
+    kind: "waiting";
+    since: number;
+};
+export declare function withoutLockfiles<T>(files: Record<string, T>): Record<string, T>;
+/** How long, and how often, content is asked whether it served the build. */
+export declare const SERVE_WAIT_MS: number;
+export declare const SERVE_POLL_MS = 5000;
+/**
+ * Build the proposal's staged files and serve the build at its address.
+ *
+ * The files and what they are for (`inputs`) come in one answer, so the build
+ * names exactly what it was made of; content refuses it if they were staged
+ * again meanwhile. The tab builds as for a publish and stops once the build is
+ * uploaded -- nothing goes live -- and content hands it to the platform.
+ *
+ * Serving can take longer than a gateway waits for an answer, and content
+ * finishes it all the same. So a gateway that gives up is not a failure: the
+ * proposal is read until it says it is built from these inputs, and served
+ * once more only if it never does.
+ */
+export declare function buildProposal<P extends BuiltProposal>(deps: {
+    name: string;
+    client: ProposalBuildClient<P>;
+    /**
+     * `target`: the proposal's own, when it changed the dependencies and builds
+     * on the layer content had built for it; `undefined` builds on the site's,
+     * as every build of a proposal did before.
+     */
+    deploy: (files: Record<string, string | null>, target: BuildTargetResponse | undefined) => Promise<StudioDeployResult>;
+    /**
+     * Whether this document can build at all (`canBuildHere`): Safari cannot,
+     * and a proposal's build has no builder tab to hand off to yet.
+     */
+    canBuildHere: () => boolean;
+    onStep?: (step: ProposalBuildStep) => void;
+    /** For tests: the clock, and waiting on it. */
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<ProposalBuildOutcome<P>>;

package/dist/declarations/src/publish/builder.d.ts

@@ -0,0 +1,22 @@
+import type * as TanstackBuild from "@valbuild/tanstack-build";
+type Builder = typeof TanstackBuild;
+/**
+ * What the Studio uses out of the builder package: five methods, each of which
+ * may answer later.
+ *
+ * Later because the builder runs in a worker (`importBuilder` in `@valbuild/ui`'s `loadBuilder.ts`), so
+ * even `bakedGit` -- synchronous in the package -- is a round trip here. The
+ * package module itself still satisfies this type, which is what lets a test
+ * hand one in.
+ */
+export type StudioBuilder = {
+    bakedGit: (...args: Parameters<Builder["bakedGit"]>) => ReturnType<Builder["bakedGit"]> | Promise<ReturnType<Builder["bakedGit"]>>;
+    rebakeGit: (...args: Parameters<Builder["rebakeGit"]>) => ReturnType<Builder["rebakeGit"]> | Promise<ReturnType<Builder["rebakeGit"]>>;
+    buildUserApp: Builder["buildUserApp"];
+    publishArtifacts: Builder["publishArtifacts"];
+    /** A build's name, before building it: see `buildInputId`. */
+    buildInputId: Builder["buildInputId"];
+    /** A tree's Val modules, as one module to evaluate: see `bundleValModules`. */
+    bundleValModules: Builder["bundleValModules"];
+};
+export {};

package/dist/declarations/src/publish/callJson.d.ts

@@ -0,0 +1,21 @@
+export declare function onPublishRefusal(listener: ((body: unknown) => void) | null): void;
+/** The publish API refused, and said why. */
+export declare class StudioPublishError extends Error {
+    readonly statusCode: number;
+    readonly body: unknown;
+    constructor(statusCode: number, message: string, body: unknown);
+}
+/**
+ * Was this a failure that asking again could get past?
+ *
+ * No answer at all (the request never got through) and the answers that mean
+ * "not now" -- a timeout, too many requests, a server or gateway error. Every
+ * other status is content answering, and the same request gets the same
+ * answer.
+ */
+export declare function isTransientPublishError(error: unknown): boolean;
+/**
+ * One JSON call through this origin, with the session cookie: its body, or a
+ * `StudioPublishError` carrying the answer's own message.
+ */
+export declare function callJson(fetchImpl: typeof fetch, url: string, method: "GET" | "POST", body?: unknown): Promise<unknown>;

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

@@ -0,0 +1,23 @@
+/**
+ * A site's build, published through content, from a browser: the deploy
+ * (read what to build and on what, build it, upload it, confirm it) and the
+ * publish job a tab runs (valbuild/home `docs/app-mode.md`, "Publishing is a
+ * queued job").
+ *
+ * Here rather than in the Studio because two pages run it: the Studio, which
+ * is a managed project's deployer, and home's upgrade page, which builds and
+ * publishes an upgrade proposal and pins this package at an exact version so
+ * that a site's own Val never reaches its upgrade (valbuild/home
+ * `docs/plans/upgrades-v2.md`, piece E). The builder is the caller's: see
+ * `StudioBuilder`.
+ */
+export type { StudioBuilder } from "./builder.js";
+export { StudioPublishError, callJson, isTransientPublishError, onPublishRefusal, } from "./callJson.js";
+export { StudioUploadError, createStudioPublishClient, isExpiredSlot, publishApiOf, type CarriedArtifact, type LivePublicFiles, type PublishApiAt, type StudioPublishClient, } from "./publishClient.js";
+export { runStudioPublish, type PublishPhase, type StudioPublishResult, } from "./runStudioPublish.js";
+export { carriedInto, runStudioDeploy, splitBinaryFiles, withCommittedFiles, type CommittedBinaryFiles, type DeployPhase, type StudioDeployOptions, type StudioDeployResult, } from "./runStudioDeploy.js";
+export { STUDIO_OUT_OF_DATE, STUDIO_OUT_OF_DATE_MESSAGE, layerMoved, loadedLayer, markStudioOutOfDate, readLiveLayer, rememberLoadedLayer, resetLoadedLayerForTests, siteMovedSinceLoad, studioOutOfDateRefusals, subscribeStudioOutOfDate, type LayerReading, } from "./loadedLayer.js";
+export { MergePrepareAnswer, createStudioJobClient, isMergeChange, type PreparedJob, type StudioJobClient, } from "./jobClient.js";
+export { RENEW_EVERY_MS, runJobToEnd, runStudioJob, type JobPhase, type StudioJobResult, } from "./runStudioJob.js";
+export { SERVE_POLL_MS, SERVE_WAIT_MS, buildProposal, withoutLockfiles, type BuiltProposal, type ProposalBuildClient, type ProposalBuildOutcome, type ProposalBuildStep, } from "./buildProposal.js";
+export { proposalProject } from "./proposalProject.js";