openplanr 3.3.0 → 3.4.0

package/lib/host-packages/claude/openplanr/runtime/design/scripts/design-review-state-store.mjs

@@ -0,0 +1,45 @@
+import {
+  planrHome
+} from "./design-runtime-home.mjs";
+
+// packages/artifact/lib/artifact/internal/review-state-store.mjs
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+var RECORD = /^(?:instance-[A-Za-z0-9_-]{22}|state-(?:default|\d+))\.json$/u;
+var AUTHORIZATION_CONTROL_VERSIONS = /* @__PURE__ */ new Set([1, 2]);
+function reviewStateDir(env = process.env) {
+  return join(planrHome(env), "artifact-daemon");
+}
+function artifactReviewStatePath(port = 0, env = process.env) {
+  const suffix = port === 0 ? "default" : String(port);
+  return join(reviewStateDir(env), `state-${suffix}.json`);
+}
+function reviewStateLockPath(port, env = process.env) {
+  const suffix = port === 0 ? "default" : String(port);
+  return join(reviewStateDir(env), `start-${suffix}.lock`);
+}
+function reviewInstanceStatePath(instanceId, env = process.env) {
+  return join(reviewStateDir(env), `instance-${instanceId}.json`);
+}
+function reviewStateRecordPaths(env = process.env) {
+  const directory = reviewStateDir(env);
+  let names;
+  try {
+    names = readdirSync(directory);
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  return names.filter((name) => RECORD.test(name)).sort().map((name) => join(directory, name));
+}
+function reviewControlHeaders(state, controlHeader) {
+  return AUTHORIZATION_CONTROL_VERSIONS.has(state.serverVersion) ? { authorization: `Bearer ${state.controlToken}` } : { [controlHeader]: state.controlToken };
+}
+
+export {
+  artifactReviewStatePath,
+  reviewStateLockPath,
+  reviewInstanceStatePath,
+  reviewStateRecordPaths,
+  reviewControlHeaders
+};

package/lib/host-packages/claude/openplanr/runtime/design/scripts/design-review.mjs

@@ -1,14 +1,25 @@
 import {
+  ARTIFACT_REVIEW_MAX_STATE_BYTES,
+  CLI_COMMAND,
+  PLANNING_FOLDER,
   assertDesignImplementationHandoff,
+  createReviewLedger,
   designImplementationHandoffDigest,
   designReviewKey,
   designReviewPath,
+  effectiveReviewDecision,
+  exportArtifactReview,
   isDesignHandoffRelativePath,
+  mergeReviewLedger,
+  readArtifactReviewState,
   readDesignExperience,
   readDesignFeedback,
   readDesignHandoff,
   readDesignHandoffReadiness,
-  updateDesignHandoff
+  resolveArtifactReviewDestination,
+  updateDesignHandoff,
+  withArtifactReviewLock,
+  writeArtifactReviewState
 } from "./design-handoff.mjs";
 import {
   createArtifactBridgeNonce,
@@ -24,43 +35,46 @@ import {
   standaloneDesignHtml,
   timingSafeTokenEqual
 } from "./design-document.mjs";
+import {
+  canonicalizeJson,
+  listDesignRevisions,
+  readDesignRevision,
+  reviewDigest
+} from "./design-shared-artifact-support-dependencies-design-support-protocol-contracts-d707e49b.mjs";
+import {
+  reviewControlHeaders,
+  reviewInstanceStatePath,
+  reviewStateRecordPaths
+} from "./design-review-state-store.mjs";
 import {
   renderArtifactShellDocument
 } from "./design-artifact-shell.mjs";
 import {
-  ARTIFACT_REVIEW_MAX_STATE_BYTES,
-  createReviewLedger,
-  effectiveReviewDecision,
-  exportArtifactReview,
+  ARTIFACT_ERROR_CODES,
+  MAX_ARTIFACT_HTML_BYTES,
+  PipelineError,
+  digestArtifactEnvelope,
+  resolveArtifactHtml,
+  validateArtifactEnvelope,
+  validateArtifactReview
+} from "./design-shared-artifact-support-protocol-contracts-9f6918b0.mjs";
+import {
+  defaultDesignRecoveryOutput,
   exportDesignShareRecovery,
   getDesignShareStatus,
+  getDesignShareStatusAsync,
   manageDesignShare,
-  mergeReviewLedger,
   publishDesignShare,
-  readArtifactReviewState,
-  resolveArtifactReviewDestination,
   shareDesign,
-  syncDesignShare,
-  withArtifactReviewLock,
-  writeArtifactReviewState
-} from "./design-share.mjs";
+  syncDesignShare
+} from "./design-share-cli-bridge.mjs";
 import {
   atomicJson,
   currentDesign,
   designSpecPath,
   hash,
-  listDesignRevisions,
-  readDesignRevision,
-  readJson,
-  reviewDigest
-} from "./design-shared-artifact-support-dependencies-design-support-protocol-contracts-3d9b1a86.mjs";
-import {
-  CLI_COMMAND,
-  PLANNING_FOLDER
-} from "./design-owner-custody.mjs";
-import {
-  planrHome
-} from "./design-runtime-home.mjs";
+  readJson
+} from "./design-shared-design-support-0bac378d.mjs";
 import {
   LOOPBACK_HOST,
   acquireStartLock,
@@ -72,18 +86,6 @@ import {
   readRequestBody,
   writePrivateJsonState
 } from "./design-loopback-server.mjs";
-import {
-  ARTIFACT_ERROR_CODES,
-  MAX_ARTIFACT_HTML_BYTES,
-  PipelineError,
-  digestArtifactEnvelope,
-  resolveArtifactHtml,
-  validateArtifactEnvelope,
-  validateArtifactReview
-} from "./design-shared-artifact-support-protocol-contracts-ea2cd15e.mjs";
-import {
-  canonicalizeJson
-} from "./design-shared-protocol-contracts-75a938cc.mjs";
 
 // packages/design/lib/design/review-export.mjs
 function reviewExportTools() {
@@ -420,9 +422,9 @@ import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join5, relative, resolve as resolve3 } from "node:path";
 
 // packages/artifact/lib/artifact/review-server.mjs
-import { existsSync, lstatSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, rmSync } from "node:fs";
 import { createServer } from "node:http";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 var here = dirname(fileURLToPath(new URL("./runtime/packages/artifact/lib/artifact/review-server.mjs", import.meta.url).href));
 var STAGE_RUNTIME_PATH = join(here, "..", "..", "templates", "artifact-review-stage.js");
@@ -431,7 +433,6 @@ var ARTIFACT_REVIEW_SERVER_KIND = "artifact-review";
 var CONTROL_HEADER = "x-openplanr-control";
 var CONTROLLABLE_SERVER_VERSIONS = /* @__PURE__ */ new Set([2, ARTIFACT_REVIEW_SERVER_VERSION]);
 var EXPORT_ONLY_SERVER_VERSIONS = /* @__PURE__ */ new Set([1]);
-var AUTHORIZATION_CONTROL_VERSIONS = /* @__PURE__ */ new Set([1, 2]);
 var CONTROL_WINDOW_BYTES = 64 * 1024 * 1024;
 var ARTIFACT_REVIEW_MAX_CONTROL_BYTES = Math.ceil((MAX_ARTIFACT_HTML_BYTES * 2 + ARTIFACT_REVIEW_MAX_STATE_BYTES) / CONTROL_WINDOW_BYTES) * CONTROL_WINDOW_BYTES;
 var ARTIFACT_REVIEW_MAX_STATE_BYTES2 = ARTIFACT_REVIEW_MAX_STATE_BYTES;
@@ -491,10 +492,7 @@ function artifactReviewControlHeaders(controlToken) {
   return { [CONTROL_HEADER]: controlToken };
 }
 function stateControlHeaders(state) {
-  return AUTHORIZATION_CONTROL_VERSIONS.has(state.serverVersion) ? { authorization: `Bearer ${state.controlToken}` } : artifactReviewControlHeaders(state.controlToken);
-}
-function reviewStateDir(env = process.env) {
-  return join(planrHome(env), "artifact-daemon");
+  return reviewControlHeaders(state, CONTROL_HEADER);
 }
 function statusForError(error) {
   if (error?.code === "E_REQUEST_BODY_LIMIT" || error?.code === ARTIFACT_ERROR_CODES.REQUEST_LIMIT)
@@ -832,7 +830,7 @@ function createArtifactReviewServer({
   }
   if (serverMetadata !== void 0 && (!serverMetadata || !["artifact", "design", "diagram"].includes(serverMetadata.kind) || typeof serverMetadata.projectRoot !== "string" || !isAbsolute(serverMetadata.projectRoot)))
     throw artifactError(ARTIFACT_ERROR_CODES.LOOPBACK_STATE, "Local server metadata is invalid.");
-  const instanceStatePath = serverMetadata ? join(reviewStateDir(env), `instance-${instanceId}.json`) : null;
+  const instanceStatePath = serverMetadata ? reviewInstanceStatePath(instanceId, env) : null;
   const sessions = /* @__PURE__ */ new Map();
   const pendingStudioIds = /* @__PURE__ */ new Set();
   const pendingMutations = /* @__PURE__ */ new Set();
@@ -1501,20 +1499,11 @@ async function controlRequest(descriptor, path, { method, body, fetchImpl } = {}
   return value;
 }
 async function discoveredArtifactServers({ env, fetchImpl }) {
-  let names;
-  try {
-    names = readdirSync(reviewStateDir(env));
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  }
   const live = /* @__PURE__ */ new Map();
-  for (const name of names.sort()) {
-    if (!/^(?:instance-[A-Za-z0-9_-]{22}|state-(?:default|\d+))\.json$/u.test(name)) continue;
-    const path = join(reviewStateDir(env), name);
+  for (const path of reviewStateRecordPaths(env)) {
     const state = readReviewServerState(path);
     if (!validState(state, 0) || !await stateIsHealthy(state, fetchImpl)) continue;
-    if (!live.has(state.instanceId) || name.startsWith("instance-"))
+    if (!live.has(state.instanceId) || basename(path).startsWith("instance-"))
       live.set(state.instanceId, state);
   }
   return [...live.values()];
@@ -1550,7 +1539,7 @@ async function stopArtifactReviewServer(instanceId, { env = process.env, fetchIm
 }
 
 // packages/protocol/src/planning-folder.mjs
-import { existsSync as existsSync2, readdirSync as readdirSync2, statSync } from "node:fs";
+import { existsSync as existsSync2, readdirSync, statSync } from "node:fs";
 import { join as join2 } from "node:path";
 var FOREIGN_FILES = Object.freeze(["planr.config.json", "board.html"]);
 var GOAL_DIRECTORIES = Object.freeze(["tasks", "plans"]);
@@ -1561,7 +1550,7 @@ function foreignPlanningFolderSigns(projectRoot2) {
   const signs = FOREIGN_FILES.filter((name) => existsSync2(join2(folder, name)));
   for (const name of GOAL_DIRECTORIES) {
     const directory = join2(folder, name);
-    if (isDirectory(directory) && readdirSync2(directory).some((entry) => entry.endsWith("-goal.md")))
+    if (isDirectory(directory) && readdirSync(directory).some((entry) => entry.endsWith("-goal.md")))
       signs.push(`*-goal.md files in ${name}`);
   }
   return signs;
@@ -1945,7 +1934,7 @@ import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypt
 import {
   existsSync as existsSync4,
   mkdirSync as mkdirSync2,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync2,
   readFileSync as readFileSync3,
   renameSync as renameSync2,
   rmSync as rmSync3,
@@ -2125,7 +2114,7 @@ function listImplementationHandoffHistory(root) {
   recoverImplementationHandoffApproval(root);
   const directory = implementationHandoffPaths(root).history;
   if (!existsSync4(directory)) return [];
-  return readdirSync3(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map(
+  return readdirSync2(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map(
     (entry) => assertImplementationHandoffProjection(readJson2(join4(directory, entry.name, "handoff.json")))
   ).sort((left, right) => left.version - right.version || left.id.localeCompare(right.id));
 }
@@ -2133,7 +2122,7 @@ function readImplementationHandoffLifecycle(root) {
   recoverImplementationHandoffApproval(root);
   const paths = implementationHandoffApprovalPaths(root);
   const current = readJson2(paths.current, null);
-  const events = existsSync4(paths.events) ? readdirSync3(paths.events).filter((name) => name.endsWith(".json")).map((name) => readJson2(join4(paths.events, name))).sort(
+  const events = existsSync4(paths.events) ? readdirSync2(paths.events).filter((name) => name.endsWith(".json")).map((name) => readJson2(join4(paths.events, name))).sort(
     (left, right) => left.at.localeCompare(right.at) || left.eventId.localeCompare(right.eventId)
   ) : [];
   return Object.freeze({ current, history: listImplementationHandoffHistory(root), events });
@@ -2489,7 +2478,7 @@ function studioContentIdentity(current) {
     })
   );
 }
-function exportDesignReview(file, { scope = "all", env = process.env } = {}) {
+function exportDesignReview(file, { scope = "all", env = process.env, shared: known } = {}) {
   if (!["all", "current"].includes(scope))
     throw new Error("Review export scope must be current or all.");
   const current = currentDesign(file), feedback = readDesignFeedback(file, env);
@@ -2518,11 +2507,12 @@ function exportDesignReview(file, { scope = "all", env = process.env } = {}) {
   const byDigest = /* @__PURE__ */ new Map();
   for (const value of local.values())
     byDigest.set(value.reviewOf, [...byDigest.get(value.reviewOf) ?? [], value]);
-  let shared = null;
-  try {
-    shared = getDesignShareStatus(file, { env });
-  } catch {
-  }
+  let shared = known ?? null;
+  if (known === void 0)
+    try {
+      shared = getDesignShareStatus(file, { env });
+    } catch {
+    }
   const currentRevisionId = shared?.publishedRevision === current.revision && shared?.revision ? shared.revision : current.revision;
   const revisions = [...local.values()];
   const entries = (feedback.ledger?.reviews ?? []).filter(
@@ -3120,8 +3110,13 @@ ${renderArtifactParentRuntime({ ...options, adapterRuntimeUrl: `${base}api/desig
           } else if (route === "design-feedback-export") {
             if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => key !== "scope") || input.scope !== void 0 && !["all", "current"].includes(input.scope))
               throw new Error("Review export requires scope current or all.");
-            await syncDesignShare(file, { env, fetchImpl });
-            respond(res, 200, exportDesignReview(file, { scope: input.scope ?? "all", env }));
+            await syncDesignShare(file, { env, fetchImpl, unavailable: "skip" });
+            const shared = await getDesignShareStatusAsync(file, { env }).catch(() => null);
+            respond(
+              res,
+              200,
+              exportDesignReview(file, { scope: input.scope ?? "all", env, shared })
+            );
           } else {
             if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !["revision", "artifactIds"].includes(key)) || input.artifactIds !== void 0 && (!Array.isArray(input.artifactIds) || input.artifactIds.length < 1 || input.artifactIds.length > 2 || input.artifactIds.some((id) => typeof id !== "string") || new Set(input.artifactIds).size !== input.artifactIds.length))
               throw new Error("Revision comparison requires one or two distinct view IDs.");
@@ -3160,7 +3155,7 @@ ${renderArtifactParentRuntime({ ...options, adapterRuntimeUrl: `${base}api/desig
             readFileSync4(new URL("../../templates/studio/share.js", new URL("./runtime/packages/design/lib/design/review.mjs", import.meta.url).href), "utf8")
           );
         } else if (route === "design-share" && req.method === "GET") {
-          respond(res, 200, getDesignShareStatus(file, { env }));
+          respond(res, 200, await getDesignShareStatusAsync(file, { env }));
         } else if (route === "design-share" && req.method === "POST") {
           if (req.headers["x-openplanr-design"] !== "1" || !String(req.headers["content-type"] ?? "").startsWith("application/json"))
             throw Object.assign(new Error("Sharing requires a same-origin studio request."), {
@@ -3180,11 +3175,7 @@ ${renderArtifactParentRuntime({ ...options, adapterRuntimeUrl: `${base}api/desig
           else if (action === "recovery")
             result = await exportDesignShareRecovery(file, {
               ...options,
-              output: join5(
-                env.HOME ?? process.env.HOME,
-                "Downloads",
-                `openplanr-design-recovery-${Date.now()}.json`
-              )
+              output: defaultDesignRecoveryOutput(env)
             });
           else result = await manageDesignShare(file, action, options);
           respond(res, 200, result);

package/lib/host-packages/claude/openplanr/runtime/design/scripts/design-runtime-home.mjs

@@ -34,6 +34,5 @@ function planrHome(env = process.env) {
 }
 
 export {
-  configuredPlanrHome,
   planrHome
 };

package/lib/host-packages/claude/openplanr/runtime/design/scripts/design-share-cli-bridge.mjs

@@ -0,0 +1,321 @@
+import {
+  currentDesign
+} from "./design-shared-design-support-0bac378d.mjs";
+import {
+  planrHome
+} from "./design-runtime-home.mjs";
+
+// packages/design/lib/design/recovery-location.mjs
+import { chmodSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+function defaultDesignRecoveryOutput(env = process.env, now = Date.now()) {
+  const directory = join(planrHome(env), "design-recovery");
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  chmodSync(directory, 448);
+  return join(directory, `openplanr-design-recovery-${now}.json`);
+}
+
+// packages/design/lib/design/share-cli-bridge.mjs
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// packages/design/lib/design/share-compat.mjs
+var DESIGN_SHARE_COMPAT = 1;
+
+// packages/design/lib/design/share-cli-bridge.mjs
+var CLI = "openplanr";
+var UPLOAD_TIMEOUT_MS = 30 * 6e4;
+var TIMEOUT_MS = 12e4;
+var STATUS_TIMEOUT_MS = 5e3;
+var FAILED_HANDSHAKE_TTL_MS = 3e4;
+var STATUS_TTL_MS = 1e4;
+var INSTALL = "Install the OpenPlanr CLI with `npm install -g openplanr`, then retry; your local design is unchanged.";
+var UNAVAILABLE = Object.freeze([
+  "E_DESIGN_SHARE_CLI_REQUIRED",
+  "E_DESIGN_SHARE_CLI_UNRESPONSIVE",
+  "E_DESIGN_SHARE_RUNTIME_MISMATCH",
+  "E_DESIGN_SHARE_PIPELINE_MISSING"
+]);
+function shareError(code, message, fix) {
+  return Object.assign(new Error(fix ? `${message} ${fix}` : message), { code, name: code });
+}
+function cliMissing() {
+  return shareError(
+    "E_DESIGN_SHARE_CLI_REQUIRED",
+    "Sharing runs in the OpenPlanr CLI, which is not installed.",
+    INSTALL
+  );
+}
+function pathOf(env) {
+  const key = Object.keys(env).find((name) => name.toUpperCase() === "PATH");
+  return key ? env[key] ?? "" : "";
+}
+function cliLauncher({
+  platform = process.platform,
+  env = process.env,
+  execPath = process.execPath
+} = {}) {
+  if (platform !== "win32") return { file: CLI, args: [] };
+  for (const directory of pathOf(env).split(";").filter(Boolean)) {
+    const shim = join2(directory, `${CLI}.cmd`);
+    if (!existsSync(shim)) continue;
+    const target = /"%~?dp0%?\\([^"\r\n]+?\.js)"/iu.exec(readFileSync(shim, "utf8"))?.[1];
+    const script = target ? join2(directory, ...target.split("\\")) : join2(directory, "node_modules", CLI, "bin", `${CLI}.js`);
+    if (existsSync(script)) return { file: execPath, args: [script] };
+  }
+  return null;
+}
+function lastJsonLine(stdout) {
+  const line = String(stdout ?? "").trim().split("\n").at(-1);
+  try {
+    return line ? JSON.parse(line) : null;
+  } catch {
+    return null;
+  }
+}
+function settle(command, timeout, error, stdout, stderr) {
+  if (error?.code === "ENOENT") throw cliMissing();
+  if (error?.code === "ETIMEDOUT" || error?.killed || error?.signal)
+    throw shareError(
+      "E_DESIGN_SHARE_CLI_UNRESPONSIVE",
+      `The OpenPlanr CLI did not finish \`artifact ${command}\` within ${Math.round(timeout / 1e3)} s.`,
+      "Check that `openplanr --version` answers, then retry."
+    );
+  const value = lastJsonLine(stdout);
+  if (!error && value && value.ok !== false) return value;
+  if (value && value.ok === false)
+    throw shareError(
+      value.code ?? "E_DESIGN_SHARE_FAILED",
+      value.problem ?? "The OpenPlanr CLI could not complete the sharing operation.",
+      value.recovery
+    );
+  const detail = String(stderr ?? "").trim().split("\n").at(-1) || error?.message || "no output";
+  throw shareError(
+    "E_DESIGN_SHARE_FAILED",
+    `openplanr artifact ${command} failed without a JSON result: ${detail}`
+  );
+}
+function argv(command, file, flags) {
+  return ["artifact", command, ...flags, "--json", ...file === void 0 ? [] : ["--", file]];
+}
+function launch(env) {
+  const launcher = cliLauncher({ env });
+  if (!launcher) throw cliMissing();
+  return launcher;
+}
+function runSync(command, file, flags, { env = process.env, timeout = STATUS_TIMEOUT_MS } = {}) {
+  const { file: program, args } = launch(env);
+  let stdout;
+  try {
+    stdout = execFileSync(program, [...args, ...argv(command, file, flags)], {
+      env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout,
+      windowsHide: true
+    });
+  } catch (error) {
+    return settle(command, timeout, error, error?.stdout, error?.stderr);
+  }
+  return settle(command, timeout, null, stdout, "");
+}
+function runAsync(command, file, flags, { env = process.env, input, timeout = TIMEOUT_MS } = {}) {
+  return new Promise((resolve, reject) => {
+    const { file: program, args } = launch(env);
+    const child = execFile(
+      program,
+      [...args, ...argv(command, file, flags)],
+      { env, encoding: "utf8", timeout, windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        try {
+          resolve(settle(command, timeout, error, stdout, stderr));
+        } catch (failure) {
+          reject(failure);
+        }
+      }
+    );
+    child.stdin?.end(input ?? "");
+  });
+}
+function compatibility(runtime, error) {
+  if (error) {
+    if (UNAVAILABLE.includes(error.code)) return { error };
+    return {
+      error: shareError(
+        "E_DESIGN_SHARE_RUNTIME_MISMATCH",
+        `The installed OpenPlanr CLI is too old to share designs for this skill (${error.message}).`,
+        "Update the CLI with `npm install -g openplanr`, then retry."
+      )
+    };
+  }
+  if (runtime.designShareCompat === DESIGN_SHARE_COMPAT) return { runtime };
+  const older = typeof runtime.designShareCompat !== "number" || runtime.designShareCompat < DESIGN_SHARE_COMPAT;
+  return {
+    error: shareError(
+      "E_DESIGN_SHARE_RUNTIME_MISMATCH",
+      `The installed OpenPlanr CLI (${runtime.cli}) shares designs in format ${runtime.designShareCompat ?? "unknown"}, but this skill uses format ${DESIGN_SHARE_COMPAT}.`,
+      older ? "Update the CLI with `npm install -g openplanr`, then retry." : "Update the OpenPlanr plugin or skills to match the CLI, then retry."
+    )
+  };
+}
+var handshakes = /* @__PURE__ */ new Map();
+function remembered(env) {
+  const known = handshakes.get(pathOf(env));
+  if (known?.outcome?.error && Date.now() - known.at > FAILED_HANDSHAKE_TTL_MS) {
+    handshakes.delete(pathOf(env));
+    return void 0;
+  }
+  return known;
+}
+function remember(env, outcome) {
+  handshakes.set(pathOf(env), { at: Date.now(), outcome });
+  return outcome;
+}
+function outcomeOf(outcome) {
+  if (outcome.error) throw outcome.error;
+  return outcome.runtime;
+}
+function requireCompatibleRuntime(env = process.env) {
+  const known = remembered(env);
+  if (known?.outcome) return outcomeOf(known.outcome);
+  let outcome;
+  try {
+    outcome = compatibility(runSync("share-runtime", void 0, [], { env }));
+  } catch (error) {
+    outcome = compatibility(null, error);
+  }
+  return outcomeOf(remember(env, outcome));
+}
+async function requireCompatibleRuntimeAsync(env = process.env) {
+  const known = remembered(env);
+  if (known?.outcome) return outcomeOf(known.outcome);
+  if (known?.pending) return outcomeOf(await known.pending);
+  const pending = runAsync("share-runtime", void 0, [], {
+    env,
+    timeout: STATUS_TIMEOUT_MS
+  }).then(
+    (runtime) => remember(env, compatibility(runtime)),
+    (error) => remember(env, compatibility(null, error))
+  );
+  handshakes.set(pathOf(env), { at: Date.now(), pending });
+  return outcomeOf(await pending);
+}
+var statuses = /* @__PURE__ */ new Map();
+function statusKey(file, env) {
+  try {
+    return `${pathOf(env)}\0${file}\0${currentDesign(file).revision}`;
+  } catch {
+    return null;
+  }
+}
+function forget(file) {
+  for (const key of statuses.keys()) if (key.split("\0")[1] === file) statuses.delete(key);
+}
+function cachedStatus(key) {
+  const known = key && statuses.get(key);
+  return known && Date.now() - known.at <= STATUS_TTL_MS ? known.value : void 0;
+}
+function unavailableStatus(error) {
+  if (!UNAVAILABLE.includes(error.code)) throw error;
+  return { ok: true, shared: false, unavailable: { code: error.code, message: error.message } };
+}
+function required(value, flag, action) {
+  if (typeof value !== "string" || !value)
+    throw shareError("E_DESIGN_SHARE_INPUT_INVALID", `${action} requires ${flag}.`);
+  return value;
+}
+async function share(command, file, flags = [], options = {}) {
+  await requireCompatibleRuntimeAsync(options.env);
+  try {
+    return await runAsync(command, file, flags, options);
+  } finally {
+    forget(file);
+  }
+}
+function assertDesignShareAvailable({ env } = {}) {
+  requireCompatibleRuntime(env);
+}
+async function shareDesign(file, options = {}) {
+  return share("share", file, ["--yes", "--no-open"], { ...options, timeout: UPLOAD_TIMEOUT_MS });
+}
+async function publishDesignShare(file, options = {}) {
+  return share("publish", file, ["--yes"], { ...options, timeout: UPLOAD_TIMEOUT_MS });
+}
+async function syncDesignShare(file, options = {}) {
+  try {
+    return await share("sync", file, [], options);
+  } catch (error) {
+    if (options.unavailable === "skip" && UNAVAILABLE.includes(error.code))
+      return { ok: true, skipped: error.code, reason: error.message };
+    throw error;
+  }
+}
+async function manageDesignShare(file, action, options = {}) {
+  return share("manage", file, ["--action", action, "--yes"], options);
+}
+async function exportDesignShareRecovery(file, { output, ...options } = {}) {
+  return share(
+    "manage",
+    file,
+    ["--action", "recovery", ...output ? ["--output", output] : []],
+    options
+  );
+}
+async function importDesignShareRecovery(file, { input, ...options } = {}) {
+  const path = required(input, "--input <private recovery file>", "Recovery restore");
+  return share("manage", file, ["--action", "restore", "--input", path, "--yes"], options);
+}
+async function publishDesignReviewMetadata(file, payload, { revisionId, ...options } = {}) {
+  const revision = required(
+    revisionId,
+    "--revision <shared revision>",
+    "Publishing review metadata"
+  );
+  return share("review-metadata", file, ["--revision", revision, "--input", "-"], {
+    ...options,
+    input: JSON.stringify(payload)
+  });
+}
+function getDesignShareStatus(file, { env } = {}) {
+  const key = statusKey(file, env);
+  const known = cachedStatus(key);
+  if (known) return known;
+  let value;
+  try {
+    requireCompatibleRuntime(env);
+    value = runSync("status", file, [], { env });
+  } catch (error) {
+    value = unavailableStatus(error);
+  }
+  if (key) statuses.set(key, { at: Date.now(), value });
+  return value;
+}
+async function getDesignShareStatusAsync(file, { env } = {}) {
+  const key = statusKey(file, env);
+  const known = cachedStatus(key);
+  if (known) return known;
+  let value;
+  try {
+    await requireCompatibleRuntimeAsync(env);
+    value = await runAsync("status", file, [], { env, timeout: STATUS_TIMEOUT_MS });
+  } catch (error) {
+    value = unavailableStatus(error);
+  }
+  if (key) statuses.set(key, { at: Date.now(), value });
+  return value;
+}
+
+export {
+  defaultDesignRecoveryOutput,
+  assertDesignShareAvailable,
+  shareDesign,
+  publishDesignShare,
+  syncDesignShare,
+  manageDesignShare,
+  exportDesignShareRecovery,
+  importDesignShareRecovery,
+  publishDesignReviewMetadata,
+  getDesignShareStatus,
+  getDesignShareStatusAsync
+};