@hasna/skills 0.5.3 → 0.5.5

package/dist/index.js

@@ -9528,7 +9528,9 @@ function normalizeSkillsApiOrigin(apiUrl) {
     throw new SkillsFleetCredentialError("A Skills API URL must use HTTPS (or loopback HTTP), without credentials, query or fragment", "INVALID_API_URL");
   }
   const pathname = url.pathname.replace(/\/+$/, "");
-  if (pathname === "/api" || pathname === "/api/v1") {
+  if (url.origin === "https://api.hasna.com" && pathname === "/skills/v1") {
+    url.pathname = "/skills";
+  } else if (pathname === "/api" || pathname === "/api/v1") {
     url.pathname = "/";
   } else if (pathname.endsWith("/api/v1")) {
     url.pathname = pathname.slice(0, -"/api/v1".length) || "/";
@@ -9537,6 +9539,21 @@ function normalizeSkillsApiOrigin(apiUrl) {
   }
   return url.toString().replace(/\/+$/, "");
 }
+function skillsApiRequestUrl(apiUrl, route) {
+  const origin = normalizeSkillsApiOrigin(apiUrl);
+  if (!route.startsWith("/api/") || route.includes("#") || route.includes("\\")) {
+    throw new SkillsFleetCredentialError("Invalid Skills API route", "INVALID_API_URL");
+  }
+  if (origin === "https://api.hasna.com/skills") {
+    if (route === "/api/auth/whoami")
+      return `${origin}/v1/auth/whoami`;
+    if (!route.startsWith("/api/v1/")) {
+      throw new SkillsFleetCredentialError("The internal Skills gateway has no established login contract yet. Select an explicitly configured instance with supported authentication.", "GATEWAY_AUTH_UNAVAILABLE");
+    }
+    return `${origin}${route.slice("/api".length)}`;
+  }
+  return `${origin}${route}`;
+}
 function configuredSkillsApiUrl(env = process.env, keychain, profile) {
   const declared = SKILLS_API_URL_ENV_KEYS.filter((key) => env[key] !== undefined).map((key) => ({ key, value: env[key] }));
   for (const entry of declared) {
@@ -9889,7 +9906,14 @@ function getConfiguredApiUrl(env = process.env) {
 }
 function buildSkillsApiUrl(apiUrl, endpoint = "/skills") {
   const url = new URL(apiUrl);
+  if (url.origin === "https://api.hasna.com" && /^\/skills\/(?:api\/)?v1\/skills\/?$/.test(url.pathname)) {
+    url.pathname = "/skills";
+    apiUrl = url.toString();
+  }
   const cleanEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+  if (normalizeSkillsApiOrigin(apiUrl) === "https://api.hasna.com/skills") {
+    return skillsApiRequestUrl(apiUrl, `/api/v1${cleanEndpoint}`);
+  }
   const pathname = url.pathname.replace(/\/+$/, "");
   const apiBase = /\/api(?:\/v1)?\/skills$/.test(pathname) ? pathname.slice(0, -"/skills".length) : pathname;
   if (/\/api(?:\/v1)?$/.test(apiBase)) {
@@ -10990,8 +11014,17 @@ function creditCount(value) {
   }
   return value;
 }
+function runQuoteReceipt(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || !value.length || Buffer.byteLength(value, "utf8") > 4096) {
+    throw new Error("Invalid quote receipt");
+  }
+  return value;
+}
 function parseRemoteRunQuote(value) {
   const quote = object(value);
+  runQuoteReceipt(quote.quoteReceipt);
   const pricing = object(quote.pricing);
   if (typeof quote.skill !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(quote.skill))
     throw new Error("Invalid quoted skill");
@@ -11138,6 +11171,69 @@ function parseUpdatedWorkspace(value) {
   return { organization: { id: organization2.id, slug: organization2.slug, name: organization2.name } };
 }
 
+// src/lib/remote-quote-errors.ts
+var quoteUnavailableMessages = Object.freeze({
+  HOSTED_PROVIDER_UNAVAILABLE: "Hosted execution is temporarily unavailable on this Skills instance.",
+  HOSTED_CONNECTORS_UNAVAILABLE: "Hosted connector execution is unavailable on this Skills instance.",
+  SKILL_IMPLEMENTATION_UNAVAILABLE: "This skill has no hosted execution implementation.",
+  HOSTED_PRICING_UNAVAILABLE: "Hosted execution is unavailable while this skill's pricing is reviewed.",
+  RUNTIME_ALLOWLIST_REQUIRED: "Hosted execution is unavailable until this Skills instance enables its skill catalog.",
+  RUNTIME_SKILL_NOT_ALLOWED: "This skill is not enabled for hosted execution on this Skills instance."
+});
+async function readQuoteUnavailableCode(response) {
+  const maximum = 16 * 1024;
+  const length = response.headers.get("content-length");
+  if (response.status !== 503 || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json" || length !== null && (!/^\d+$/.test(length) || Number(length) > maximum)) {
+    response.body?.cancel().catch(() => {});
+    return null;
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    return null;
+  let timer;
+  let deadlineExceeded = false;
+  const expired = Symbol("quote body deadline");
+  const deadline = new Promise((resolve2) => {
+    timer = setTimeout(() => {
+      deadlineExceeded = true;
+      resolve2(expired);
+      reader.cancel().catch(() => {});
+    }, 1500);
+  });
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const next = await Promise.race([reader.read(), deadline]);
+      if (next === expired || deadlineExceeded)
+        return null;
+      if (next.done)
+        break;
+      size += next.value.byteLength;
+      if (size > maximum)
+        return null;
+      chunks.push(next.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return null;
+    const code = value.code;
+    return typeof code === "string" && Object.hasOwn(quoteUnavailableMessages, code) ? code : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
 // src/lib/remote-client.ts
 class RemoteRouteUnsupportedError extends Error {
   path;
@@ -11163,6 +11259,18 @@ class RemoteRequestError extends Error {
   }
 }
 
+class RemoteQuoteUnavailableError extends RemoteRequestError {
+  code;
+  constructor(path, code) {
+    super(path, 503);
+    this.code = code;
+    if (!Object.hasOwn(quoteUnavailableMessages, code))
+      throw new Error("Unknown quote refusal code");
+    this.name = "RemoteQuoteUnavailableError";
+    this.message = quoteUnavailableMessages[code];
+  }
+}
+
 class RemoteWorkspaceMemberError extends RemoteRequestError {
   code;
   constructor(path, code) {
@@ -11201,7 +11309,7 @@ class RemoteSkillsClient {
     this.apiUrl = normalizeSkillsApiOrigin(apiUrl);
   }
   async request(path, options) {
-    return fetch(`${this.apiUrl}${path}`, {
+    return fetch(skillsApiRequestUrl(this.apiUrl, path), {
       ...options,
       redirect: "error",
       credentials: "omit",
@@ -11224,6 +11332,11 @@ class RemoteSkillsClient {
       throw new RemoteRouteUnsupportedError(routePath, response.status, this.apiUrl);
     }
     if (!response.ok) {
+      if (opts.quoteRefusal && options?.method === "POST" && /^\/api\/v1\/skills\/[^/?#]+\/quote$/.test(routePath) && response.status === 503) {
+        const code = await readQuoteUnavailableCode(response);
+        if (code)
+          throw new RemoteQuoteUnavailableError(routePath, code);
+      }
       if (path === "/api/v1/billing/checkout" && options?.method === "POST" && response.status === 503 && await responseBodyCarriesCode(response, ["SUBSCRIPTION_CHECKOUT_UNAVAILABLE"])) {
         throw new RemoteCapabilityUnavailableError;
       }
@@ -11256,6 +11369,7 @@ class RemoteSkillsClient {
     return { status: res.status, body };
   }
   async submitRun(slug, input, args, approval = {}) {
+    const quoteReceipt = runQuoteReceipt(approval.quoteReceipt);
     if (approval.idempotencyKey !== undefined && !/^[A-Za-z0-9._:-]{1,128}$/.test(approval.idempotencyKey))
       throw new Error("Idempotency key must be 1-128 URL-safe characters");
     if (approval.maxCostCents !== undefined)
@@ -11272,16 +11386,21 @@ class RemoteSkillsClient {
         ...approval.maxCredits !== undefined ? { maxCredits: approval.maxCredits } : {},
         ...approval.maxCostCents !== undefined ? { maxCostCents: approval.maxCostCents } : {},
         ...approval.idempotencyKey !== undefined ? { idempotencyKey: approval.idempotencyKey } : {},
-        ...approval.inputFiles !== undefined ? { files: approval.inputFiles } : {}
+        ...approval.inputFiles !== undefined ? { files: approval.inputFiles } : {},
+        ...quoteReceipt !== undefined ? { quoteReceipt } : {}
       })
     });
+    if (!res.ok) {
+      res.body?.cancel().catch(() => {});
+      throw new RemoteRequestError(`/api/v1/runs/${encodeURIComponent(slug)}`, res.status);
+    }
     return normalizeRemoteSkillRunContract(await res.json(), slug);
   }
-  async quoteRun(slug, input = {}, args = []) {
+  async quoteRun(slug, input = {}, args = [], files) {
     const response = await this.requestNewRoute(`/api/v1/skills/${encodeURIComponent(slug)}/quote`, {
       method: "POST",
-      body: JSON.stringify({ input, args })
-    });
+      body: JSON.stringify({ input, args, ...files === undefined ? {} : { files } })
+    }, { quoteRefusal: true });
     return parseRemoteRunQuote(await response.json());
   }
   getCapabilities() {
@@ -11296,17 +11415,24 @@ class RemoteSkillsClient {
     return this.capabilities;
   }
   async submitQuotedRun(slug, input = {}, args = [], approval = {}) {
+    runQuoteReceipt(approval.quoteReceipt);
+    ({ input, args, approval } = JSON.parse(JSON.stringify({ input, args, approval })));
     const maximum = creditCount(approval.maxCredits ?? approval.maxCostCents ?? 0);
     if (approval.maxCostCents !== undefined && approval.maxCostCents !== maximum)
       throw new Error("Credit approval fields disagree");
-    const quote = await this.quoteRun(slug, input, args);
-    if (quote.pricing.costCents > maximum)
+    const quote = approval.quoteReceipt === undefined ? await this.quoteRun(slug, input, args, approval.inputFiles?.length ? approval.inputFiles : undefined) : undefined;
+    if (quote && quote.pricing.costCents > maximum)
       throw new RemoteCreditApprovalError(quote.pricing.costCents, maximum);
     const capabilities = await this.getCapabilities();
     if (!capabilities.capabilities.includes("runs.submit") || capabilities.billing?.boundedRunApproval !== true || capabilities.billing.unit !== "credits") {
       throw new Error("The configured server does not support bounded credit approval; refusing remote submission");
     }
-    return this.submitRun(quote.skill, input, args, { ...approval, maxCredits: maximum, maxCostCents: maximum });
+    return this.submitRun(quote?.skill ?? slug, input, args, {
+      ...approval,
+      maxCredits: maximum,
+      maxCostCents: maximum,
+      ...(quote?.quoteReceipt ?? approval.quoteReceipt) === undefined ? {} : { quoteReceipt: quote?.quoteReceipt ?? approval.quoteReceipt }
+    });
   }
   async getIdentity() {
     return (await this.requestNewRoute("/api/auth/whoami")).json();
@@ -11594,6 +11720,10 @@ class RemoteSkillsClient {
     return { id: artifactId, fileName: String(artifact.fileName ?? artifactId), bytes, byteSize: bytes.byteLength, sha256: artifact.sha256 };
   }
   async submitQuotedRunWithFiles(slug, input, args, files, approval = {}) {
+    runQuoteReceipt(approval.quoteReceipt);
+    ({ input, args, approval } = JSON.parse(JSON.stringify({ input, args, approval })));
+    describeRemoteFiles(files);
+    files = files.map((file) => ({ name: file.name, contentType: file.contentType, bytes: new Uint8Array(file.bytes) }));
     const inputFiles = describeRemoteFiles(files);
     if (files.length && !(await this.getCapabilities()).capabilities.includes("runs.uploads"))
       throw new Error("The configured server does not support input uploads");
@@ -11657,7 +11787,7 @@ class RemoteSkillsClient {
     const headers = { Authorization: `Bearer ${this.apiKey}` };
     if (ifMatch)
       headers["If-Match"] = ifMatch;
-    return fetch(`${this.apiUrl}/api/v1/skills`, {
+    return fetch(skillsApiRequestUrl(this.apiUrl, "/api/v1/skills"), {
       method: "POST",
       headers,
       body: form,
@@ -13206,7 +13336,7 @@ import { dirname as dirname7, relative as relative4 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.5.3",
+  version: "0.5.5",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -13940,7 +14070,7 @@ var toolContracts = [
     name: "run_skill",
     title: "Run Skill",
     description: "Run a skill locally or through a configured remote runner. Returns compact stdout/stderr previews and run summaries by default; pass detail:true for full records.",
-    params: ["name", "input?", "args?", "detail?", "remote?", "maxCredits?", "maxCostCents?", "idempotency_key?", "files?"],
+    params: ["name", "input?", "args?", "detail?", "remote?", "maxCredits?", "maxCostCents?", "quoteReceipt?", "idempotency_key?", "files?"],
     category: "execution",
     sideEffects: "local-process-or-remote-run",
     stable: true,
@@ -13952,6 +14082,7 @@ var toolContracts = [
       remote: { type: "boolean", description: "Use the configured server catalog." },
       maxCredits: { type: "integer", minimum: 0, description: "Maximum explicitly approved integer credits; omitted permits only free remote runs." },
       maxCostCents: { type: "integer", minimum: 0, description: "Legacy alias for maxCredits; both must agree." },
+      quoteReceipt: { type: "string", minLength: 1, maxLength: 4096, description: "Opaque approved quote receipt, at most 4096 UTF-8 bytes. Preserve it and the quoted input/args unchanged; never refresh after confirmation." },
       idempotency_key: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Stable retry key for the same remote submission." },
       files: { type: "array", maxItems: 10, items: objectSchema({ name: stringSchema("Safe basename"), base64: { type: "string", maxLength: 1398104 }, contentType: stringSchema("MIME type") }, ["name", "base64"]), description: "Inline remote inputs, at most 1 MiB combined." }
     }, ["name"]),
@@ -14235,12 +14366,17 @@ remoteCustomerContracts.push({
   name: "quote_skill",
   title: "Quote Remote Skill",
   description: "Get a server credit quote without submitting a run.",
-  params: ["name", "input?", "args?"],
+  params: ["name", "input?", "args?", "files?"],
   category: "execution",
   sideEffects: "none",
   stable: true,
-  inputSchema: objectSchema({ name: skillNameInput, input: runInputSchema, args: runArgsSchema }, ["name"]),
-  outputSchema: objectSchema({ skill: stringSchema("Canonical server skill."), pricing: objectSchema({}, [], "Quoted integer credits.", true) }, ["skill", "pricing"], undefined, true)
+  inputSchema: objectSchema({
+    name: skillNameInput,
+    input: runInputSchema,
+    args: runArgsSchema,
+    files: { type: "array", maxItems: 10, items: objectSchema({ name: stringSchema("Safe basename"), base64: { type: "string", maxLength: 1398104 }, contentType: stringSchema("MIME type") }, ["name", "base64"]), description: "Same inline files to submit after approval, at most 1 MiB combined." }
+  }, ["name"]),
+  outputSchema: objectSchema({ skill: stringSchema("Canonical server skill."), pricing: objectSchema({}, [], "Quoted integer credits.", true), quoteReceipt: { type: "string", minLength: 1, maxLength: 4096, description: "Opaque server quote binding, at most 4096 UTF-8 bytes; preserve verbatim for approval." } }, ["skill", "pricing"], undefined, true)
 });
 remoteCustomerContracts.push({
   name: "download_run_artifact",
@@ -14253,7 +14389,47 @@ remoteCustomerContracts.push({
   inputSchema: objectSchema({ run_id: stringSchema("Run identifier."), artifact_id: stringSchema("Artifact identifier.") }, ["run_id", "artifact_id"]),
   outputSchema: objectSchema({ id: stringSchema("Artifact identifier."), fileName: stringSchema("Artifact file name."), base64: stringSchema("Verified bytes."), sha256: stringSchema("SHA256 digest."), byteSize: { type: "integer", minimum: 0 } }, ["id", "fileName", "base64", "sha256", "byteSize"])
 });
-var contracts = [...toolContracts, ...remoteCustomerContracts].sort((a, b) => a.name.localeCompare(b.name));
+var publicationUuidSchema = { type: "string", pattern: "^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$" };
+var publicationVerification = {
+  email: { type: "string", format: "email", maxLength: 254 },
+  code: { type: "string", pattern: "^\\d{6}$" },
+  userId: publicationUuidSchema,
+  membershipId: publicationUuidSchema,
+  recoveryDirectory: { type: "string", maxLength: 4096, description: "Absolute host-local recovery directory without symbolic links." }
+};
+var privatePublicationContracts = [
+  { name: "publish_private_skill", title: "Publish private skill", extras: {
+    directory: { type: "string", maxLength: 4096, description: "Absolute local skill source directory." },
+    skillId: publicationUuidSchema,
+    expectedCurrentVersionId: { oneOf: [publicationUuidSchema, { type: "null" }] },
+    idempotencyKey: publicationUuidSchema,
+    confirm: { const: true },
+    waitMs: { type: "integer", minimum: 0, maximum: 300000 }
+  }, required: ["directory", "skillId", "expectedCurrentVersionId", "confirm"] },
+  { name: "get_private_publication", title: "Get private publication", extras: {}, required: [] },
+  { name: "resume_private_publication", title: "Resume private publication", extras: { confirm: { const: true }, waitMs: { type: "integer", minimum: 0, maximum: 300000 } }, required: ["confirm"] },
+  { name: "cancel_private_publication", title: "Cancel private publication", extras: { confirm: { const: true } }, required: ["confirm"] }
+].map((operation) => ({
+  name: operation.name,
+  title: operation.title,
+  description: "Manage private source publication with fresh workspace verification and durable host-local recovery. Upload consent and current version comparison are explicit; private execution remains unavailable.",
+  params: [...Object.keys(publicationVerification), ...Object.keys(operation.extras)],
+  category: "storage",
+  sideEffects: "filesystem",
+  stable: true,
+  inputSchema: objectSchema({ ...publicationVerification, ...operation.extras }, [...Object.keys(publicationVerification), ...operation.required]),
+  outputSchema: objectSchema({
+    recoveryDirectory: { type: "string" },
+    skillId: publicationUuidSchema,
+    intentId: { oneOf: [publicationUuidSchema, { type: "null" }] },
+    state: { type: "string" },
+    versionId: { oneOf: [publicationUuidSchema, { type: "null" }] },
+    committed: { type: "boolean" },
+    executionEnabled: { const: false },
+    nextAction: { type: "string" }
+  }, ["recoveryDirectory", "skillId", "intentId", "state", "versionId", "committed", "executionEnabled", "nextAction"])
+}));
+var contracts = [...toolContracts, ...remoteCustomerContracts, ...privatePublicationContracts].sort((a, b) => a.name.localeCompare(b.name));
 var resourceContracts = [
   {
     uri: "skills://mcp/contracts",
@@ -15740,7 +15916,7 @@ async function requestInvitationEmail(origin, action, input) {
   }
   const body = JSON.stringify({ invitationId: value.invitationId, token: value.token, challengeId: value.challengeId, ...action === "accept" ? { code: value.code } : {} });
   try {
-    const response = await fetch(`${target}/api/v1/account/invitations/email-${action}`, {
+    const response = await fetch(skillsApiRequestUrl(target, `/api/v1/account/invitations/email-${action}`), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body,
@@ -15771,6 +15947,312 @@ async function requestInvitationEmail(origin, action, input) {
   throw new RemoteInvitationEmailUnconfirmedError(action);
 }
 
+// src/lib/remote-private-publications.ts
+import { createHash as createHash9 } from "crypto";
+var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
+var failures = {
+  INVALID_REQUEST: [400, "The publication request is invalid."],
+  SESSION_EXPIRED: [401, "Sign in again to manage this publication."],
+  ACCOUNT_UNAVAILABLE: [403, "The account is unavailable."],
+  INTERACTIVE_SESSION_REQUIRED: [403, "An interactive account session is required."],
+  PUBLICATION_FORBIDDEN: [403, "This session cannot manage the publication."],
+  PUBLICATION_ENTITLEMENT_REQUIRED: [403, "The workspace is not entitled to publish private skills."],
+  PUBLICATION_UNAVAILABLE: [404, "The publication is unavailable to this session."],
+  MANIFEST_NAME_MISMATCH: [409, "The manifest name does not match the selected skill."],
+  IDEMPOTENCY_CONFLICT: [409, "This request key already identifies different publication bytes. Use the saved recovery directory."],
+  CURRENT_VERSION_CHANGED: [409, "The current version changed. Inspect it before explicitly starting another publication."],
+  VERSION_EXISTS: [409, "This version already exists."],
+  VERSION_RESERVED: [409, "This version is reserved by another publication."],
+  PUBLICATION_COMMITTED: [409, "The publication is already committed."],
+  PUBLICATION_UPLOAD_UNAVAILABLE: [409, "This publication cannot receive another upload."],
+  PUBLICATION_LIMIT: [429, "The workspace publication limit has been reached."],
+  PUBLICATION_BUSY: [503, "The publication is busy. Reconcile the saved intent before retrying."],
+  PUBLICATION_UNCERTAIN: [503, "The publication outcome is uncertain. Reconcile the saved intent."],
+  PUBLICATION_CAPABILITY_UNAVAILABLE: [503, "Private publishing is not enabled on this server."],
+  PUBLICATION_SIGNING_UNAVAILABLE: [503, "Upload authorization is temporarily unavailable. Keep the same intent."]
+};
+
+class PrivatePublicationError extends Error {
+  code;
+  uncertain;
+  status;
+  constructor(code, message, uncertain = false, status) {
+    super(message);
+    this.code = code;
+    this.uncertain = uncertain;
+    this.status = status;
+    this.name = "PrivatePublicationError";
+  }
+}
+var bad = () => {
+  throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
+};
+var invalid3 = () => {
+  throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
+};
+var publicationUuid = (v) => typeof v === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v);
+var hash = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
+var record5 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var exact = (v, keys) => record5(v) && Object.keys(v).sort().join(",") === keys.sort().join(",");
+var date = (v) => typeof v === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v) && Number.isFinite(Date.parse(v));
+var publicationSha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex");
+function checkedPublicationDeclaration(value) {
+  if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
+    return bad();
+  try {
+    const manifest = JSON.parse(value.manifestText);
+    if (!record5(manifest) || manifest.version !== value.version || validatePortableManifestContract(manifest, { strict: true }).length || !hash(manifest.provenance?.content_hash))
+      return bad();
+  } catch {
+    return bad();
+  }
+  return Object.freeze({ ...value });
+}
+function checkedPublicationView(value, skillId, intentId, declaration) {
+  if (!exact(value, ["id", "skillId", "version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize", "state", "expiresAt", "createdAt", "versionId"]) || !publicationUuid(value.id) || value.skillId !== skillId || intentId !== undefined && value.id !== intentId || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || !hash(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES || typeof value.state !== "string" || !["awaiting_upload", "queued", "verifying", "needs_attention", "committed", "rejected", "cancelled", "expired"].includes(value.state) || !date(value.expiresAt) || !date(value.createdAt) || !(value.versionId === null || publicationUuid(value.versionId)) || value.state === "committed" && value.versionId === null)
+    return invalid3();
+  if (declaration && ["version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize"].some((k) => value[k] !== declaration[k]))
+    return invalid3();
+  return Object.freeze({ ...value });
+}
+async function boundedJson(url, init, token, mutation, budget = 15000, signal) {
+  const controller = new AbortController;
+  let reader;
+  let response;
+  const timeout = new PrivatePublicationError("PUBLICATION_UNCONFIRMED", "No confirmed publication result. Inspect the saved intent before retrying.", mutation);
+  let timer;
+  let abort;
+  try {
+    return await Promise.race([(async () => {
+      if (signal?.aborted)
+        throw timeout;
+      response = await fetch(url, {
+        ...init,
+        redirect: "error",
+        credentials: "omit",
+        signal: controller.signal,
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }
+      });
+      const length = response.headers.get("content-length");
+      if (length !== null && (!/^\d+$/.test(length) || Number(length) > 65536))
+        return invalid3();
+      reader = response.body?.getReader();
+      const chunks = [];
+      let size = 0;
+      if (reader)
+        while (true) {
+          const part = await reader.read();
+          if (part.done)
+            break;
+          size += part.value.byteLength;
+          if (size > 65536)
+            return invalid3();
+          chunks.push(part.value);
+        }
+      if (controller.signal.aborted)
+        throw timeout;
+      const bytes = Buffer.concat(chunks);
+      let body;
+      try {
+        body = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+      } catch {
+        return invalid3();
+      }
+      if (!response.ok) {
+        const code = record5(body) && typeof body.code === "string" && Object.hasOwn(failures, body.code) ? body.code : null;
+        if (code && failures[code][0] === response.status)
+          throw new PrivatePublicationError(code, failures[code][1], mutation && code === "PUBLICATION_UNCERTAIN", response.status);
+        throw new PrivatePublicationError("PUBLICATION_REQUEST_FAILED", "The publication request was refused. Inspect its status before retrying.", mutation && response.status >= 500, response.status);
+      }
+      return body;
+    })(), new Promise((_, reject) => {
+      abort = () => {
+        controller.abort();
+        reject(timeout);
+      };
+      timer = setTimeout(abort, Math.max(1, Math.min(15000, budget)));
+      signal?.addEventListener("abort", abort, { once: true });
+    })]);
+  } catch (error) {
+    if (error instanceof PrivatePublicationError) {
+      if (mutation && error.code === "INVALID_PUBLICATION_RESPONSE")
+        throw timeout;
+      throw error;
+    }
+    throw timeout;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    if (abort)
+      signal?.removeEventListener("abort", abort);
+    controller.abort();
+    if (reader)
+      reader.cancel().catch(() => {});
+    else
+      response?.body?.cancel().catch(() => {});
+  }
+}
+
+class RemotePrivatePublicationsClient {
+  apiOrigin;
+  organizationId;
+  userId;
+  membershipId;
+  #token;
+  constructor(apiUrl, session) {
+    const checked = parseWorkspaceSession(session, { userId: session?.user?.id, membershipId: session?.user?.membershipId });
+    if (checked.user.role === "viewer")
+      throw new PrivatePublicationError("PUBLICATION_FORBIDDEN", failures.PUBLICATION_FORBIDDEN[1]);
+    this.apiOrigin = normalizeSkillsApiOrigin(apiUrl);
+    this.#token = checked.token;
+    this.organizationId = checked.organization.id;
+    this.userId = checked.user.id;
+    this.membershipId = checked.user.membershipId;
+    Object.freeze(this);
+  }
+  async getCapability(options = {}) {
+    if (options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 15000))
+      return bad();
+    const response = await boundedJson(skillsApiRequestUrl(this.apiOrigin, "/api/v1/capabilities"), {}, this.#token, false, options.timeoutMs, options.signal);
+    const p = record5(response) && response.privatePublishing;
+    if (!record5(response) || response.contractVersion !== 1 || response.apiVersion !== 1 || !exact(p, ["contractVersion", "enabled", "authentication", "maxArchiveBytes", "uploadMaxTtlSeconds", "executionEnabled"]) || p.contractVersion !== 1 || typeof p.enabled !== "boolean" || p.authentication !== "interactive-session" || p.maxArchiveBytes !== PRIVATE_PUBLICATION_MAX_BYTES || p.uploadMaxTtlSeconds !== 300 || p.executionEnabled !== false)
+      throw new PrivatePublicationError("PUBLICATION_CONTRACT_UNAVAILABLE", "This server does not support the hosted private publication contract.");
+    return Object.freeze({ ...p });
+  }
+  async#gate(enabled, options = {}) {
+    if (!(await this.getCapability(options)).enabled && enabled)
+      throw new PrivatePublicationError("PUBLICATION_CAPABILITY_UNAVAILABLE", failures.PUBLICATION_CAPABILITY_UNAVAILABLE[1]);
+  }
+  #path(skillId, intentId) {
+    if (!publicationUuid(skillId) || intentId !== undefined && !publicationUuid(intentId))
+      return bad();
+    return skillsApiRequestUrl(this.apiOrigin, `/api/v1/skills/${skillId}/publication-uploads${intentId ? `/${intentId}` : ""}`);
+  }
+  async#view(path, method, skillId, intentId, declaration, options = {}) {
+    const value = await boundedJson(path, { method, ...method === "GET" ? {} : { body: JSON.stringify(declaration ?? {}) } }, this.#token, method !== "GET", options.timeoutMs, options.signal);
+    try {
+      if (!record5(value) || !Object.keys(value).every((k) => k === "upload" || k === "changed") || value.changed !== undefined && typeof value.changed !== "boolean")
+        return invalid3();
+      return checkedPublicationView(value.upload, skillId, intentId, declaration);
+    } catch (error) {
+      if (method !== "GET")
+        throw new PrivatePublicationError("PUBLICATION_UNCONFIRMED", "The publication result could not be confirmed. Reconcile the saved intent before another action.", true);
+      throw error;
+    }
+  }
+  async begin(skillId, input) {
+    const path = this.#path(skillId), declaration = checkedPublicationDeclaration(input);
+    await this.#gate(true);
+    return this.#view(path, "POST", skillId, undefined, declaration);
+  }
+  async get(skillId, intentId, options = {}) {
+    const path = this.#path(skillId, intentId), until = Date.now() + (options.timeoutMs ?? 15000);
+    await this.#gate(false, options);
+    return this.#view(path, "GET", skillId, intentId, undefined, { ...options, timeoutMs: Math.max(1, until - Date.now()) });
+  }
+  async finalize(skillId, intentId) {
+    const path = this.#path(skillId, intentId);
+    await this.#gate(true);
+    return this.#view(`${path}/finalize`, "POST", skillId, intentId);
+  }
+  async cancel(skillId, intentId) {
+    const path = this.#path(skillId, intentId);
+    await this.#gate(false);
+    return this.#view(path, "DELETE", skillId, intentId);
+  }
+  async upload(skillId, intent, bytes) {
+    const captured = checkedPublicationView(intent, skillId), path = this.#path(skillId, captured.id);
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== captured.archiveByteSize)
+      return bad();
+    const owned = Buffer.from(bytes);
+    if (captured.state !== "awaiting_upload" || owned.byteLength !== captured.archiveByteSize || publicationSha256(owned) !== captured.archiveSha256)
+      return bad();
+    await this.#gate(true);
+    const value = await boundedJson(`${path}/upload-url`, { method: "POST", body: "{}" }, this.#token, false);
+    const upload = this.#upload(value, captured);
+    const controller = new AbortController;
+    let timer;
+    const uncertain = () => new PrivatePublicationError("PUBLICATION_UPLOAD_UNCONFIRMED", "Upload acceptance is uncertain. Resume this saved intent to finalize and inspect it; do not upload again.", true);
+    try {
+      await Promise.race([(async () => {
+        const response = await fetch(upload.uploadUrl, { method: "PUT", headers: upload.headers, body: owned, redirect: "error", credentials: "omit", signal: controller.signal });
+        response.body?.cancel().catch(() => {});
+        if (response.status !== 200 || controller.signal.aborted)
+          throw uncertain();
+      })(), new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          reject(uncertain());
+        }, 30000);
+      })]);
+    } catch {
+      throw uncertain();
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      controller.abort();
+    }
+  }
+  #upload(value, intent) {
+    if (!exact(value, ["upload"]) || !exact(value.upload, ["method", "uploadUrl", "headers", "expiresAt"]))
+      return invalid3();
+    const p = value.upload;
+    if (p.method !== "PUT" || typeof p.uploadUrl !== "string" || p.uploadUrl.length > 8192 || /[\x00-\x20\x7f]/.test(p.uploadUrl) || !date(p.expiresAt) || Date.parse(p.expiresAt) - Date.now() < 1000 || Date.parse(p.expiresAt) - Date.now() > 300000 || Date.parse(p.expiresAt) > Date.parse(intent.expiresAt) || !exact(p.headers, ["content-type", "content-length", "x-amz-checksum-sha256", "x-amz-expected-bucket-owner"]) || p.headers["content-type"] !== "application/gzip" || p.headers["content-length"] !== String(intent.archiveByteSize) || p.headers["x-amz-checksum-sha256"] !== Buffer.from(intent.archiveSha256, "hex").toString("base64") || typeof p.headers["x-amz-expected-bucket-owner"] !== "string" || !/^\d{12}$/.test(p.headers["x-amz-expected-bucket-owner"]))
+      return invalid3();
+    let url;
+    try {
+      url = new URL(p.uploadUrl);
+    } catch {
+      return invalid3();
+    }
+    if (url.protocol !== "https:" || url.port || url.username || url.password || url.hash || !/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]\.s3\.[a-z]{2}(?:-[a-z]+)+-[1-9]\.amazonaws\.com$/.test(url.hostname) || url.pathname !== `/private-publication-staging/${this.organizationId}/${intent.id}/bundle.tgz` || !url.search || url.searchParams.get("X-Amz-Algorithm") !== "AWS4-HMAC-SHA256" || url.searchParams.get("X-Amz-SignedHeaders") !== "content-length;content-type;host;x-amz-checksum-sha256;x-amz-expected-bucket-owner" || !/^[a-f0-9]{64}$/.test(url.searchParams.get("X-Amz-Signature") ?? ""))
+      return invalid3();
+    const queryKeys = ["X-Amz-Algorithm", "X-Amz-Credential", "X-Amz-Date", "X-Amz-Expires", "X-Amz-Security-Token", "X-Amz-Signature", "X-Amz-SignedHeaders"];
+    if ([...url.searchParams.keys()].sort().join(",") !== queryKeys.sort().join(","))
+      return invalid3();
+    const issued = url.searchParams.get("X-Amz-Date"), ttl = url.searchParams.get("X-Amz-Expires"), credential = url.searchParams.get("X-Amz-Credential");
+    const timestamp3 = /^(\d{4})(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z$/.exec(issued);
+    const region = url.hostname.split(".s3.")[1].split(".amazonaws.com")[0];
+    if (!timestamp3 || !/^[1-9]\d{0,2}$/.test(ttl) || Number(ttl) > 300 || !/^[A-Z0-9]{16,128}\//.test(credential) || credential.split("/").slice(1).join("/") !== `${issued.slice(0, 8)}/${region}/s3/aws4_request` || !/^[\x21-\x7e]{1,4096}$/.test(url.searchParams.get("X-Amz-Security-Token")))
+      return invalid3();
+    const issuedAt = Date.parse(`${timestamp3[1]}-${timestamp3[2]}-${timestamp3[3]}T${timestamp3[4]}:${timestamp3[5]}:${timestamp3[6]}Z`);
+    if (!Number.isFinite(issuedAt) || issuedAt > Date.now() + 1000 || issuedAt + Number(ttl) * 1000 !== Date.parse(p.expiresAt))
+      return invalid3();
+    return { method: "PUT", uploadUrl: url.href, expiresAt: p.expiresAt, headers: Object.freeze({ ...p.headers }) };
+  }
+  async wait(skillId, intentId, options = {}) {
+    const timeout = options.timeoutMs ?? 60000;
+    if (!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 300000)
+      return bad();
+    const until = Date.now() + timeout;
+    let previous;
+    while (true) {
+      if (options.signal?.aborted)
+        throw new PrivatePublicationError("PUBLICATION_WAIT_ABORTED", "Stopped waiting. The server publication continues; inspect the saved intent.");
+      let view;
+      try {
+        view = await this.get(skillId, intentId, { timeoutMs: timeout === 0 ? 15000 : Math.max(1, Math.min(15000, until - Date.now())), signal: options.signal });
+      } catch (error) {
+        if (previous && Date.now() >= until && !options.signal?.aborted)
+          return previous;
+        throw error;
+      }
+      previous = view;
+      if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
+        return view;
+      await new Promise((resolve4) => {
+        const timer = setTimeout(done, Math.min(1000, until - Date.now()));
+        function done() {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", done);
+          resolve4();
+        }
+        options.signal?.addEventListener("abort", done, { once: true });
+      });
+    }
+  }
+}
+
 // src/lib/remote-auth.ts
 var MAX_ERROR_DETAIL_LENGTH = 200;
 
@@ -15793,10 +16275,11 @@ class HostedApiError extends Error {
 async function requestAuthApi(instance, path, options) {
   const url = normalizeSkillsApiOrigin(instance);
   const safeUrl = url;
-  const endpoint = `${(options?.method || "GET").toUpperCase()} ${safeUrl}${path}`;
+  const requestUrl = skillsApiRequestUrl(url, path);
+  const endpoint = `${(options?.method || "GET").toUpperCase()} ${requestUrl}`;
   let res;
   try {
-    res = await fetch(`${url}${path}`, {
+    res = await fetch(requestUrl, {
       ...options,
       redirect: "error",
       signal: options?.signal ?? AbortSignal.timeout(15000),
@@ -15811,10 +16294,10 @@ async function requestAuthApi(instance, path, options) {
   const text2 = await res.text();
   const body = text2 ? parseJsonBody(text2) : {};
   if (!res.ok) {
-    const record5 = isRecord5(body) ? body : {};
-    const detail = typeof record5.detail === "string" ? record5.detail : undefined;
-    const error = typeof record5.error === "string" ? record5.error : undefined;
-    const code = typeof record5.code === "string" ? record5.code : undefined;
+    const record6 = isRecord5(body) ? body : {};
+    const detail = typeof record6.detail === "string" ? record6.detail : undefined;
+    const error = typeof record6.error === "string" ? record6.error : undefined;
+    const code = typeof record6.code === "string" ? record6.code : undefined;
     throw new HostedApiError(detail || error || `${res.status} ${res.statusText}`, {
       status: res.status,
       code,
@@ -15848,6 +16331,10 @@ class RemoteSkillsAuthClient {
   constructor(apiUrl) {
     this.apiOrigin = normalizeSkillsApiOrigin(apiUrl);
   }
+  async openPrivatePublications(email2, code, context) {
+    const origin = this.apiOrigin, captured = workspaceContext(context);
+    return new RemotePrivatePublicationsClient(origin, await this.switchWorkspace(email2, code, captured));
+  }
   requestInvitationEmailChallenge(input) {
     return requestInvitationEmail(this.apiOrigin, "challenge", input);
   }
@@ -15895,9 +16382,10 @@ class RemoteSkillsAuthClient {
     const apiOrigin = this.apiOrigin;
     if (typeof email2 !== "string" || !email2.includes("@") || typeof code !== "string" || !/^\d{6}$/.test(code))
       throw new Error("Fresh email and six-digit verification code are required to manage this account");
+    const requestUrl = skillsApiRequestUrl(apiOrigin, "/api/auth/verify");
     let response;
     try {
-      response = await fetch(`${apiOrigin}/api/auth/verify`, {
+      response = await fetch(requestUrl, {
         method: "POST",
         redirect: "error",
         credentials: "omit",
@@ -15988,6 +16476,242 @@ class RemoteSkillsAuthClient {
     return requestAuthApi(this.apiOrigin, path, options);
   }
 }
+// src/lib/private-publication-recovery.ts
+import { constants as constants2, closeSync as closeSync3, fsyncSync, fstatSync as fstatSync3, lstatSync as lstatSync5, mkdirSync as mkdirSync14, openSync as openSync3, readSync as readSync2, realpathSync as realpathSync2, renameSync as renameSync4, unlinkSync, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname12, isAbsolute as isAbsolute5, join as join22, resolve as resolve4 } from "path";
+import { randomUUID } from "crypto";
+var fail2 = () => {
+  throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
+};
+function safeDirectory(directory) {
+  if (!isAbsolute5(directory) || directory !== resolve4(directory) || realpathSync2(directory) !== directory)
+    return fail2();
+  for (let path = directory;; path = dirname12(path)) {
+    const stat = lstatSync5(path);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+      return fail2();
+    if (path === dirname12(path))
+      break;
+  }
+  const own = lstatSync5(directory);
+  if ((own.mode & 63) !== 0 || process.getuid && own.uid !== process.getuid())
+    return fail2();
+  return { dev: own.dev, ino: own.ino };
+}
+function unchangedDirectory(directory, identity) {
+  const now = safeDirectory(directory);
+  if (now.dev !== identity.dev || now.ino !== identity.ino)
+    return fail2();
+}
+function readOwned(directory, name, max) {
+  const identity = safeDirectory(directory), file = join22(directory, name);
+  const fd = openSync3(file, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    const stat = fstatSync3(fd);
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > max || stat.size < 1 || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
+      return fail2();
+    const buffer = Buffer.alloc(Math.min(max, stat.size) + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const count = readSync2(fd, buffer, length, buffer.length - length, length);
+      if (count === 0)
+        break;
+      length += count;
+    }
+    const bytes = buffer.subarray(0, length), after = fstatSync3(fd);
+    unchangedDirectory(directory, identity);
+    if (bytes.length !== stat.size || stat.size !== after.size || stat.mtimeMs !== after.mtimeMs || stat.ctimeMs !== after.ctimeMs)
+      return fail2();
+    return bytes;
+  } finally {
+    closeSync3(fd);
+  }
+}
+function writeOwned(directory, name, bytes) {
+  const fd = openSync3(join22(directory, name), constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  try {
+    writeFileSync13(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync3(fd);
+  }
+}
+function save(directory, value) {
+  const identity = safeDirectory(directory), temporary = `.receipt-${randomUUID()}.json`;
+  writeOwned(directory, temporary, JSON.stringify(value) + `
+`);
+  unchangedDirectory(directory, identity);
+  renameSync4(join22(directory, temporary), join22(directory, "receipt.json"));
+  const fd = openSync3(directory, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync3(fd);
+  }
+}
+function bind(client, receipt) {
+  if (["apiOrigin", "organizationId", "userId", "membershipId"].some((k) => client[k] !== receipt[k]))
+    throw new PrivatePublicationError("PUBLICATION_IDENTITY_CHANGED", "The fresh session does not match the recovery directory's server, account and membership.");
+}
+async function locked(directory, action) {
+  const identity = safeDirectory(directory), file = join22(directory, "operation.lock");
+  let fd;
+  try {
+    fd = openSync3(file, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  } catch {
+    throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
+  }
+  const lock = fstatSync3(fd);
+  try {
+    writeFileSync13(fd, JSON.stringify({ pid: process.pid }) + `
+`);
+    fsyncSync(fd);
+    return await action();
+  } finally {
+    closeSync3(fd);
+    unchangedDirectory(directory, identity);
+    const now = lstatSync5(file);
+    if (now.dev !== lock.dev || now.ino !== lock.ino || !now.isFile() || now.isSymbolicLink())
+      fail2();
+    unlinkSync(file);
+  }
+}
+function readPrivatePublicationRecovery(directory) {
+  try {
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readOwned(directory, "receipt.json", 65536)));
+    if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== ["contractVersion", "apiOrigin", "organizationId", "userId", "membershipId", "skillId", "declaration", "phase", "intent"].sort().join(",") || value.contractVersion !== 1 || ![value.organizationId, value.userId, value.membershipId, value.skillId].every(publicationUuid) || typeof value.apiOrigin !== "string" || normalizeSkillsApiOrigin(value.apiOrigin) !== value.apiOrigin || !["prepared", "begin_uncertain", "awaiting_upload", "upload_uncertain", "uploaded", "finalize_uncertain", "observed"].includes(value.phase))
+      return fail2();
+    value.declaration = checkedPublicationDeclaration(value.declaration);
+    if (value.intent !== null)
+      value.intent = checkedPublicationView(value.intent, value.skillId, undefined, value.declaration);
+    if (value.intent === null && !["prepared", "begin_uncertain"].includes(value.phase))
+      return fail2();
+    const bytes = readOwned(directory, "bundle.tgz", PRIVATE_PUBLICATION_MAX_BYTES);
+    if (bytes.length !== value.declaration.archiveByteSize || publicationSha256(bytes) !== value.declaration.archiveSha256)
+      return fail2();
+    return { receipt: value, bytes };
+  } catch {
+    return fail2();
+  }
+}
+async function preparePrivatePublication(client, sourceDirectory, recoveryDirectory, input) {
+  if (!publicationUuid(input.skillId) || !(input.expectedCurrentVersionId === null || publicationUuid(input.expectedCurrentVersionId)) || input.idempotencyKey !== undefined && !publicationUuid(input.idempotencyKey))
+    return fail2();
+  const packed = packSkillBundle(sourceDirectory, { maxUnpackedBytes: 32 * 1024 * 1024 });
+  const inspected = await inspectSkillBundle(packed.bytes, { limits: { compressedBytes: PRIVATE_PUBLICATION_MAX_BYTES } });
+  const manifest = inspected.entries.find((entry) => entry.path === "skill.json");
+  if (!manifest || manifest.bytes.length > 16384 || !(await verifyContentHashFromEntries(inspected.entries)).valid)
+    throw new PrivatePublicationError("PUBLICATION_BUNDLE_INVALID", "The skill must have a valid skill.json with its current content hash. Validate the skill before publishing.");
+  const manifestText = new TextDecoder("utf-8", { fatal: true }).decode(manifest.bytes);
+  const declaration = checkedPublicationDeclaration({
+    idempotencyKey: input.idempotencyKey ?? randomUUID(),
+    version: JSON.parse(manifestText).version,
+    expectedCurrentVersionId: input.expectedCurrentVersionId,
+    manifestText,
+    archiveSha256: inspected.sha256,
+    archiveByteSize: packed.bytes.length
+  });
+  const receipt = {
+    contractVersion: 1,
+    apiOrigin: client.apiOrigin,
+    organizationId: client.organizationId,
+    userId: client.userId,
+    membershipId: client.membershipId,
+    skillId: input.skillId,
+    declaration,
+    phase: "prepared",
+    intent: null
+  };
+  if (!isAbsolute5(recoveryDirectory) || resolve4(recoveryDirectory) !== recoveryDirectory || realpathSync2(dirname12(recoveryDirectory)) !== dirname12(recoveryDirectory))
+    return fail2();
+  mkdirSync14(recoveryDirectory, { mode: 448 });
+  safeDirectory(recoveryDirectory);
+  const parent = openSync3(dirname12(recoveryDirectory), constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    fsyncSync(parent);
+  } finally {
+    closeSync3(parent);
+  }
+  writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
+  save(recoveryDirectory, receipt);
+  return receipt;
+}
+function privatePublicationResult(directory, receipt) {
+  const state = receipt.intent?.state ?? receipt.phase, committed = state === "committed";
+  const nextAction = committed ? "The version is published. Private execution remains unavailable." : ["rejected", "cancelled", "expired"].includes(state) ? "This intent is terminal. Inspect the result before explicitly preparing another version." : state === "needs_attention" ? "Keep this intent and contact the service operator; do not create a replacement or upload again." : receipt.phase === "upload_uncertain" ? "Run publication resume with this recovery directory to finalize the same intent without another upload." : receipt.intent ? "Run publication status or resume with this recovery directory; cancel explicitly if you want to stop." : "Run publication resume with this recovery directory to reconcile the identical request key and declaration.";
+  return {
+    recoveryDirectory: directory,
+    skillId: receipt.skillId,
+    intentId: receipt.intent?.id ?? null,
+    state,
+    versionId: receipt.intent?.versionId ?? null,
+    committed,
+    executionEnabled: false,
+    nextAction
+  };
+}
+async function continuePrivatePublication(client, directory, options) {
+  if (options.confirm !== true)
+    throw new PrivatePublicationError("PUBLICATION_CONFIRM_REQUIRED", "Explicit upload confirmation is required.");
+  if (options.waitMs !== undefined && (!Number.isSafeInteger(options.waitMs) || options.waitMs < 0 || options.waitMs > 300000))
+    return fail2();
+  return locked(directory, () => continueLocked(client, directory, options));
+}
+async function continueLocked(client, directory, options) {
+  const { receipt, bytes } = readPrivatePublicationRecovery(directory);
+  bind(client, receipt);
+  if (!receipt.intent) {
+    receipt.phase = "begin_uncertain";
+    save(directory, receipt);
+    receipt.intent = await client.begin(receipt.skillId, receipt.declaration);
+    receipt.phase = "awaiting_upload";
+    save(directory, receipt);
+  } else {
+    receipt.intent = checkedPublicationView(await client.get(receipt.skillId, receipt.intent.id), receipt.skillId, receipt.intent.id, receipt.declaration);
+    save(directory, receipt);
+  }
+  if (receipt.intent.state === "awaiting_upload") {
+    if (receipt.phase === "awaiting_upload") {
+      receipt.phase = "upload_uncertain";
+      save(directory, receipt);
+      try {
+        await client.upload(receipt.skillId, receipt.intent, bytes);
+      } catch (error) {
+        if (error instanceof PrivatePublicationError && !error.uncertain) {
+          receipt.phase = "awaiting_upload";
+          save(directory, receipt);
+        }
+        throw error;
+      }
+      receipt.phase = "uploaded";
+      save(directory, receipt);
+    }
+    receipt.phase = "finalize_uncertain";
+    save(directory, receipt);
+    receipt.intent = checkedPublicationView(await client.finalize(receipt.skillId, receipt.intent.id), receipt.skillId, receipt.intent.id, receipt.declaration);
+    receipt.phase = "observed";
+    save(directory, receipt);
+  }
+  if (options.waitMs !== undefined && options.waitMs > 0 && ["queued", "verifying"].includes(receipt.intent.state)) {
+    receipt.intent = checkedPublicationView(await client.wait(receipt.skillId, receipt.intent.id, { timeoutMs: options.waitMs }), receipt.skillId, receipt.intent.id, receipt.declaration);
+    receipt.phase = "observed";
+    save(directory, receipt);
+  }
+  return privatePublicationResult(directory, receipt);
+}
+async function inspectPrivatePublication(client, directory, cancel = false) {
+  return locked(directory, () => inspectLocked(client, directory, cancel));
+}
+async function inspectLocked(client, directory, cancel) {
+  const { receipt } = readPrivatePublicationRecovery(directory);
+  bind(client, receipt);
+  if (receipt.intent) {
+    receipt.intent = checkedPublicationView(await (cancel ? client.cancel(receipt.skillId, receipt.intent.id) : client.get(receipt.skillId, receipt.intent.id)), receipt.skillId, receipt.intent.id, receipt.declaration);
+    save(directory, receipt);
+  } else if (cancel)
+    throw new PrivatePublicationError("PUBLICATION_INTENT_UNKNOWN", "Reconcile the saved begin request with publication resume before cancelling its intent.");
+  return privatePublicationResult(directory, receipt);
+}
 export {
   writeStationSnapshot,
   writeStationHydration,
@@ -16050,11 +16774,13 @@ export {
   removeSchedule,
   removeManagedAgentSkill,
   recordScheduleRun,
+  readPrivatePublicationRecovery,
   readPortableSkillManifest,
   pullSkills,
   publicDiscoveryEnvVars,
   publicDiscoveryDocumentation,
   publicDiscoveryDependencies,
+  preparePrivatePublication,
   portPortableSkillDirectory,
   portPortableSkill,
   pointerSkillMd,
@@ -16098,6 +16824,7 @@ export {
   installSkillManifest,
   installSkillForAgent,
   installSkill,
+  inspectPrivatePublication,
   importSkillsLocalSnapshot,
   homePathFor,
   getToolPrimitive,
@@ -16161,6 +16888,7 @@ export {
   createRegistrySyncArtifact,
   createMcpContractManifest,
   createLocalSkillManifest,
+  continuePrivatePublication,
   configuredSkillsApiUrl,
   computeContentHashFromEntries,
   computeContentHash,
@@ -16219,6 +16947,8 @@ export {
   RemoteSkillsAuthClient,
   RemoteRouteUnsupportedError,
   RemoteRequestError,
+  RemoteQuoteUnavailableError,
+  RemotePrivatePublicationsClient,
   RemoteInvitationEmailUnconfirmedError,
   RemoteInvitationEmailError,
   RemoteCreditApprovalError,
@@ -16226,7 +16956,9 @@ export {
   REMOTE_SKILL_RUN_CONTRACT_VERSION,
   REFUSED_SCANNER_FLAGGED,
   PullSkillError,
+  PrivatePublicationError,
   PROJECT_CONFIG_FILE,
+  PRIVATE_PUBLICATION_MAX_BYTES,
   PORTABLE_SKILL_STANDARD,
   PORTABLE_SKILL_SCHEMA,
   PORTABLE_SKILL_DEFAULT_VERSION,