@tinycloud/operations 0.3.4-beta.6 → 0.4.0-beta.11

package/dist/delegation-binding.js

@@ -0,0 +1,1403 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms2) {
+      var msAbs = Math.abs(ms2);
+      if (msAbs >= d) {
+        return Math.round(ms2 / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms2 / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms2 / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms2 / s) + "s";
+      }
+      return ms2 + "ms";
+    }
+    function fmtLong(ms2) {
+      var msAbs = Math.abs(ms2);
+      if (msAbs >= d) {
+        return plural(ms2, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms2, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms2, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms2, msAbs, s, "second");
+      }
+      return ms2 + " ms";
+    }
+    function plural(ms2, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// src/delegation-binding.ts
+import { join as join2 } from "path";
+import * as nodeSdk2 from "@tinycloud/node-sdk";
+
+// src/artifacts.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { z } from "zod";
+
+// ../sdk-core/src/manifest.ts
+var import_ms = __toESM(require_ms(), 1);
+import { resolveSecretPath, SECRET_NAME_RE } from "@tinycloud/sdk-services";
+var DEFAULT_MANIFEST_SPACE = "applications";
+var SERVICE_SHORT_TO_LONG = Object.freeze({
+  kv: "tinycloud.kv",
+  sql: "tinycloud.sql",
+  duckdb: "tinycloud.duckdb",
+  capabilities: "tinycloud.capabilities",
+  hooks: "tinycloud.hooks",
+  encryption: "tinycloud.encryption",
+  delegation: "tinycloud.delegation"
+});
+var SERVICE_LONG_TO_SHORT = Object.freeze(
+  Object.fromEntries(
+    Object.entries(SERVICE_SHORT_TO_LONG).map(([s, l]) => [l, s])
+  )
+);
+function expandActionShortNames(service, actions) {
+  return actions.map((a) => {
+    if (a.includes("/")) {
+      return a;
+    }
+    return `${service}/${a}`;
+  });
+}
+
+// ../sdk-core/src/capabilities.ts
+function normalizeSpace(space) {
+  if (!space.startsWith("tinycloud:")) {
+    return space;
+  }
+  const lastColon = space.lastIndexOf(":");
+  if (lastColon === -1 || lastColon === space.length - 1) {
+    return space;
+  }
+  return space.slice(lastColon + 1);
+}
+function isCapabilitySubset(requested, granted) {
+  const missing = [];
+  for (const req of requested) {
+    const matchingScope = granted.filter(
+      (entry) => canonicalizeEntryScopeMatches(req, entry)
+    );
+    const requestedActions = expandActionShortNames(
+      req.service,
+      req.actions
+    );
+    const grantedActions = matchingScope.flatMap(
+      (entry) => expandActionShortNames(entry.service, entry.actions)
+    );
+    const covered = requestedActions.every(
+      (requestedAction) => grantedActions.some(
+        (grantedAction) => actionContains(grantedAction, requestedAction)
+      )
+    );
+    if (!covered) {
+      missing.push(cloneEntry(req));
+    }
+  }
+  return { subset: missing.length === 0, missing };
+}
+function canonicalizeEntryScopeMatches(requested, granted) {
+  if (requested.service !== granted.service) {
+    return false;
+  }
+  if (normalizeSpace(requested.space ?? DEFAULT_MANIFEST_SPACE) !== normalizeSpace(granted.space ?? DEFAULT_MANIFEST_SPACE)) {
+    return false;
+  }
+  if (!pathContains(granted.path, requested.path)) {
+    return false;
+  }
+  if (!recapCaveatsEqual(requested.caveats, granted.caveats)) {
+    return false;
+  }
+  return true;
+}
+function recapCaveatsEqual(left, right) {
+  return canonicalizeRecapCaveats(left) === canonicalizeRecapCaveats(right);
+}
+function canonicalizeRecapCaveats(caveats) {
+  const canonicalize = (value) => {
+    if (value === null || typeof value === "boolean" || typeof value === "string") {
+      return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+      if (Number.isFinite(value)) return JSON.stringify(value);
+      throw new Error("ReCap caveats must contain only JSON values.");
+    }
+    if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+    if (typeof value === "object") {
+      const object = value;
+      const prototype = Object.getPrototypeOf(object);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error("ReCap caveats must contain only JSON values.");
+      }
+      return `{${Object.keys(object).sort().map(
+        (key) => `${JSON.stringify(key)}:${canonicalize(object[key])}`
+      ).join(",")}}`;
+    }
+    throw new Error("ReCap caveats must contain only JSON values.");
+  };
+  const branches = (caveats ?? []).map(canonicalize).sort();
+  if (branches.length === 0 || branches.length === 1 && branches[0] === "{}") {
+    return "[]";
+  }
+  return `[${branches.join(",")}]`;
+}
+function actionContains(grantedAction, requestedAction) {
+  if (grantedAction === "*" || grantedAction === requestedAction) return true;
+  if (!grantedAction.endsWith("/*")) return false;
+  const service = grantedAction.slice(0, -2);
+  return requestedAction === service || requestedAction.startsWith(`${service}/`);
+}
+function pathContains(grantedPath, requestedPath) {
+  if (grantedPath === "" || grantedPath === "/") {
+    return true;
+  }
+  if (grantedPath.endsWith("/")) {
+    return requestedPath.startsWith(grantedPath);
+  }
+  return requestedPath === grantedPath;
+}
+function cloneEntry(entry) {
+  return {
+    service: entry.service,
+    ...entry.space !== void 0 ? { space: entry.space } : {},
+    path: entry.path,
+    actions: [...entry.actions],
+    ...entry.caveats !== void 0 ? { caveats: JSON.parse(JSON.stringify(entry.caveats)) } : {},
+    ...entry.skipPrefix !== void 0 ? { skipPrefix: entry.skipPrefix } : {},
+    ...entry.expiry !== void 0 ? { expiry: entry.expiry } : {}
+  };
+}
+
+// src/authority.ts
+function evaluateOperationAuthority(granted, required, resolveSpace) {
+  const canonicalGranted = canonicalizeOperationCapabilities(granted, resolveSpace);
+  const canonicalRequired = canonicalizeOperationCapabilities(required, resolveSpace);
+  const missing = [];
+  for (const requested of canonicalRequired) {
+    const covered = canonicalGranted.some(
+      (candidate) => candidate.service === requested.service && operationSpacesEqual(candidate.space, requested.space) && isCapabilitySubset([requested], [candidate]).subset
+    );
+    if (!covered) missing.push(requested);
+  }
+  return {
+    satisfied: missing.length === 0,
+    missing: canonicalizeCapabilities(missing)
+  };
+}
+function delegationWithinRequest(requested, effective, resolveSpace) {
+  return requested.length > 0 && evaluateOperationAuthority(requested, canonicalizeCapabilities(effective), resolveSpace).satisfied;
+}
+function canonicalizeOperationCapabilities(permissions, resolveSpace) {
+  return canonicalizeCapabilities(permissions.map((permission) => {
+    const canonicalPath = canonicalizeOperationPath(permission);
+    if (permission.space === void 0 || resolveSpace === void 0) {
+      return canonicalPath;
+    }
+    try {
+      return { ...canonicalPath, space: resolveSpace(permission.space) };
+    } catch {
+      return canonicalPath;
+    }
+  }));
+}
+function canonicalizeOperationPath(permission) {
+  if (permission.service !== "tinycloud.encryption") return permission;
+  const match = permission.path.match(
+    /^(urn:tinycloud:encryption:did:pkh:eip155:\d+:)(0x[0-9a-fA-F]{40})(:.*)$/
+  );
+  if (!match) return permission;
+  return { ...permission, path: `${match[1]}${match[2].toLowerCase()}${match[3]}` };
+}
+function operationSpacesEqual(granted, requested) {
+  return granted === requested;
+}
+function canonicalizeCapabilities(permissions) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const permission of permissions) {
+    const canonical = canonicalizeCapability(permission);
+    byIdentity.set(permissionIdentityFromCanonical(canonical), canonical);
+  }
+  return [...byIdentity.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, permission]) => permission);
+}
+function canonicalizeCapability(permission) {
+  const actions = [...new Set(permission.actions)].sort((left, right) => left.localeCompare(right));
+  return {
+    service: permission.service,
+    ...permission.space !== void 0 ? { space: permission.space } : {},
+    path: permission.path,
+    actions,
+    ...permission.skipPrefix !== void 0 ? { skipPrefix: permission.skipPrefix } : {},
+    ...permission.expiry !== void 0 ? { expiry: permission.expiry } : {},
+    ...permission.description !== void 0 ? { description: permission.description } : {},
+    ...permission.caveats === void 0 ? {} : { caveats: canonicalizeCaveats(permission.caveats) }
+  };
+}
+function permissionIdentityFromCanonical(permission) {
+  return JSON.stringify({
+    service: permission.service,
+    ...permission.space !== void 0 ? { space: permission.space } : {},
+    path: permission.path,
+    actions: permission.actions,
+    ...permission.skipPrefix !== void 0 ? { skipPrefix: permission.skipPrefix } : {},
+    ...permission.expiry !== void 0 ? { expiry: permission.expiry } : {},
+    ...permission.description !== void 0 ? { description: permission.description } : {},
+    ...permission.caveats === void 0 ? {} : { caveats: permission.caveats }
+  });
+}
+function canonicalizeCaveats(caveats) {
+  return [...caveats].map((caveat) => ({
+    identity: canonicalizeRecapCaveats([caveat]),
+    value: JSON.parse(JSON.stringify(caveat))
+  })).sort((left, right) => left.identity.localeCompare(right.identity)).map(({ value }) => value);
+}
+
+// src/state.ts
+import { randomUUID } from "crypto";
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  chmod,
+  link,
+  mkdir,
+  open,
+  readFile,
+  readdir,
+  rename,
+  rmdir,
+  rm,
+  stat,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+var DEFAULT_LOCK_TIMEOUT_MS = 2e3;
+var DEFAULT_LOCK_RETRY_MS = 25;
+var DEFAULT_STALE_LOCK_MS = 3e4;
+var TEST_LOCK_CONTENTION_SIGNAL_PATH = "TC_TEST_PROFILE_LOCK_CONTENTION_SIGNAL_PATH";
+var PRIVATE_FILE_MODE = 384;
+var PRIVATE_DIR_MODE = 448;
+var TEST_LOCK_RECOVERY_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RECOVERY_BARRIER_DIR";
+var TEST_LOCK_OWNERLESS_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_OWNERLESS_BARRIER_DIR";
+var TEST_LOCK_PUBLISH_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_PUBLISH_BARRIER_DIR";
+var TEST_LOCK_RELEASE_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RELEASE_BARRIER_DIR";
+var TEST_LOCK_CLAIM_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIM_BARRIER_DIR";
+var TEST_LOCK_CLAIMED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIMED_BARRIER_DIR";
+var TEST_LOCK_VERIFIED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_VERIFIED_BARRIER_DIR";
+var TEST_LOCK_MOVED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_MOVED_BARRIER_DIR";
+var TEST_LOCK_TURN_PUBLISH_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_TURN_PUBLISH_BARRIER_DIR";
+var TEST_LOCK_TURN_SETTLE_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_TURN_SETTLE_BARRIER_DIR";
+var TEST_LOCK_TURN_COLLECT_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_TURN_COLLECT_BARRIER_DIR";
+function processWideContext(key) {
+  var _a2;
+  const registry = globalThis;
+  return registry[_a2 = Symbol.for(key)] ?? (registry[_a2] = new AsyncLocalStorage());
+}
+var invocationStateRoot = processWideContext("tinycloud.operations.invocationStateRoot.v1");
+var heldProfileLocks = processWideContext("tinycloud.operations.heldProfileLocks.v2");
+var ProfileLockTimeoutError = class extends Error {
+  /** `detail` names the cause when it is not simply another process holding the lock. */
+  constructor(profile, timeoutMs, detail) {
+    super(`Timed out waiting for the profile lock for "${profile}" after ${timeoutMs}ms.${detail ? ` ${detail}` : ""}`);
+    this.code = "PROFILE_LOCK_TIMEOUT";
+    this.name = "ProfileLockTimeoutError";
+  }
+};
+var ProfileDeletedError = class extends Error {
+  constructor(profile) {
+    super(`Profile "${profile}" was deleted while this change waited for its lock, so the change was not written.`);
+    this.code = "PROFILE_NOT_FOUND";
+    this.name = "ProfileDeletedError";
+  }
+};
+function tinycloudHomePath() {
+  const home = invocationStateRoot.getStore() ?? process.env.TC_HOME ?? process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+  return join(home, ".tinycloud");
+}
+function profilesPath() {
+  return join(tinycloudHomePath(), "profiles");
+}
+function profilePath(profile) {
+  return join(profilesPath(), validateProfileName(profile));
+}
+function profileConfigPath(profile) {
+  return join(profilePath(profile), "profile.json");
+}
+function sessionPath(profile) {
+  return profileStorePath(profile, "session");
+}
+function profileStorePath(profile, store) {
+  return join(profilePath(profile), `${store}.json`);
+}
+function profileStoreMetadataPath(profile, store) {
+  return `${profileStorePath(profile, store)}.metadata.json`;
+}
+function profileLockPath(profile) {
+  return join(profilePath(profile), ".lock");
+}
+function profileTurnLockPath(profile) {
+  return join(tinycloudHomePath(), "profile-locks", validateProfileName(profile));
+}
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return null;
+    throw error;
+  }
+}
+async function writeJsonAtomic(filePath, value) {
+  await replaceJson(filePath, value, false);
+}
+async function replaceJson(filePath, value, durable) {
+  const directory = dirname(filePath);
+  const temporaryPath = join(
+    directory,
+    `.${basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  const contents = `${JSON.stringify(value, null, 2)}
+`;
+  await mkdir(directory, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    if (durable) await writeFileDurably(temporaryPath, contents);
+    else await writeFile(temporaryPath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function writeFileDurably(path, contents) {
+  const handle = await open(path, "wx", PRIVATE_FILE_MODE);
+  try {
+    if (contents) {
+      await handle.writeFile(contents, "utf8");
+      await handle.datasync();
+    }
+  } finally {
+    await handle.close();
+  }
+}
+async function readSession(profile) {
+  await readStoreMetadata(profile, "session");
+  return readJson(sessionPath(profile));
+}
+async function readAdditionalDelegations(profile) {
+  return (await readProfileStore(profile, "additional-delegations")).records;
+}
+async function readStoreMetadata(profile, store) {
+  const metadata = await readJson(profileStoreMetadataPath(profile, store));
+  if (metadata === null) return { formatVersion: 1 };
+  if (typeof metadata !== "object" || metadata.formatVersion !== 1) {
+    throw new TypeError(`Unsupported store format for "${store}".`);
+  }
+  return metadata;
+}
+async function readProfileStore(profile, store) {
+  const [metadata, raw] = await Promise.all([
+    readStoreMetadata(profile, store),
+    readJson(profileStorePath(profile, store))
+  ]);
+  return {
+    formatVersion: metadata.formatVersion,
+    records: Array.isArray(raw) ? raw : []
+  };
+}
+async function withProfileLock(profile, action, options = {}) {
+  const normalizedProfile = validateProfileName(profile);
+  const lockPath = profileLockPath(normalizedProfile);
+  const held = (heldProfileLocks.getStore() ?? []).filter((ownership2) => ownership2.active);
+  if (held.some((ownership2) => ownership2.lockPath === lockPath)) return action();
+  const acquired = await acquireProfileLock(normalizedProfile, options);
+  const ownership = {
+    lockPath,
+    turnSlot: acquired.turnSlot,
+    deletedWhileWaiting: acquired.deletedWhileWaiting,
+    active: true
+  };
+  try {
+    return await heldProfileLocks.run([...held, ownership], action);
+  } finally {
+    ownership.active = false;
+    await acquired.release();
+    if (acquired.deletedWhileWaiting) await rmdir(profilePath(normalizedProfile)).catch(() => void 0);
+  }
+}
+async function refuseWriteToDeletedProfile(profile) {
+  const lockPath = profileLockPath(profile);
+  const ownership = (heldProfileLocks.getStore() ?? []).find((candidate) => candidate.active && candidate.lockPath === lockPath);
+  if (!ownership?.deletedWhileWaiting) return;
+  if (await exists(profileConfigPath(profile))) return;
+  throw new ProfileDeletedError(profile);
+}
+async function updateProfileStore(profile, store, update, options = {}) {
+  return withProfileLock(
+    profile,
+    () => updateProfileStoreWhileLocked(profile, store, update),
+    options
+  );
+}
+async function updateProfileStoreWhileLocked(profile, store, update) {
+  await refuseWriteToDeletedProfile(profile);
+  const current = await readProfileStore(profile, store);
+  const next = await update(current.records);
+  await writeJsonAtomic(profileStorePath(profile, store), next.records);
+  await writeFormatOneMetadata(profile, store);
+  return next.result;
+}
+async function writeFormatOneMetadata(profile, store) {
+  await writeJsonAtomic(profileStoreMetadataPath(profile, store), { formatVersion: 1 });
+}
+async function acquireProfileLock(profile, options) {
+  const deadline = {
+    startedAt: Date.now(),
+    timeoutMs: options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS,
+    retryMs: options.retryMs ?? DEFAULT_LOCK_RETRY_MS
+  };
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_MS;
+  const lockPath = profileLockPath(profile);
+  const turnDirectory = profileTurnLockPath(profile);
+  const directory = profilePath(profile);
+  await mkdir(directory, { recursive: true, mode: PRIVATE_DIR_MODE });
+  await mkdir(dirname(turnDirectory), { recursive: true, mode: PRIVATE_DIR_MODE });
+  for (const path of [tinycloudHomePath(), profilesPath(), directory]) {
+    await chmod(path, PRIVATE_DIR_MODE).catch((error) => {
+      if (path !== directory || !isErrno(error, "ENOENT")) throw error;
+    });
+  }
+  const { turn, firstWaitedTurn } = await acquireTurn(profile, turnDirectory, deadline);
+  try {
+    const deletion = await readJson(join(turnDirectory, "deleted.json")).catch(() => null);
+    const deletedWhileWaiting = typeof deletion?.slot === "number" && deletion.slot >= firstWaitedTurn;
+    while (true) {
+      const token = randomUUID();
+      if (await publishProfileLock(profile, lockPath, token)) {
+        return {
+          deletedWhileWaiting,
+          turnSlot: turn.slot,
+          release: async () => {
+            try {
+              await releaseProfileLock(profile, lockPath, token);
+            } finally {
+              await releaseTurn(profile, turn);
+            }
+          }
+        };
+      }
+      await signalTestLockContention(profile);
+      if (await recoverStaleLock(profile, lockPath, staleAfterMs)) continue;
+      await waitOrTimeOut(profile, deadline);
+    }
+  } catch (error) {
+    await releaseTurn(profile, turn);
+    throw error;
+  }
+}
+function checkDeadline(profile, deadline, detail) {
+  if (Date.now() - deadline.startedAt >= deadline.timeoutMs) {
+    throw new ProfileLockTimeoutError(profile, deadline.timeoutMs, detail);
+  }
+}
+async function waitOrTimeOut(profile, deadline, detail) {
+  checkDeadline(profile, deadline, detail);
+  await sleep(Math.min(deadline.retryMs, deadline.timeoutMs - (Date.now() - deadline.startedAt)));
+}
+var TURN = /^(?:0|[1-9][0-9]*)$/;
+var _a;
+var relinquishedTurns = globalThis[_a = /* @__PURE__ */ Symbol.for("tinycloud.operations.relinquishedProfileTurns.v1")] ?? (globalThis[_a] = /* @__PURE__ */ new Set());
+var MARKER_RETRY_DELAYS_MS = [10, 50, 250];
+var SETTLE_RETRY_MS = 1e3;
+var SETTLE_RETRIES = 300;
+async function acquireTurn(profile, directory, deadline) {
+  let firstWaitedTurn;
+  let problem;
+  const damaged = (what) => `The turn lock ${directory} ${what}, so no process can take it. If no tc or MCP process is using profile "${profile}", remove that directory.`;
+  for (let first = true; ; first = false) {
+    if (!first) checkDeadline(profile, deadline, problem);
+    problem = void 0;
+    const latest = await readLatestTurn(directory);
+    if (latest === "missing") {
+      await createTurnDirectory(directory);
+      continue;
+    }
+    if (latest === "empty") {
+      problem = damaged("has no turns");
+      await waitOrTimeOut(profile, deadline, problem);
+      continue;
+    }
+    if (latest === null) continue;
+    if (typeof latest === "number") {
+      problem = damaged(`has an unreadable turn ${latest}`);
+      await waitOrTimeOut(profile, deadline, problem);
+      continue;
+    }
+    firstWaitedTurn ?? (firstWaitedTurn = latest.done ? latest.slot + 1 : latest.slot);
+    if (latest.held && latest.done) {
+      const turn = await takeTurn(profile, directory, latest);
+      if (turn !== null) return { turn, firstWaitedTurn };
+      await waitOrTimeOut(profile, deadline);
+    } else if (latest.done) {
+      problem = damaged(`ends with turn ${latest.slot}, which was never granted`);
+      await waitOrTimeOut(profile, deadline, problem);
+    } else if (latest.pid === process.pid ? relinquishedTurns.has(latest.token) : !isProcessAlive(latest.pid)) {
+      await waitForTestBarrier(TEST_LOCK_TURN_SETTLE_BARRIER_DIR, profile);
+      await settleAbandonedTurn(directory, latest);
+      relinquishedTurns.delete(latest.token);
+    } else {
+      await signalTestLockContention(profile);
+      await waitOrTimeOut(profile, deadline);
+    }
+  }
+}
+async function readLatestTurn(directory) {
+  let names;
+  try {
+    names = await readdir(directory);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return "missing";
+    throw error;
+  }
+  const slots = names.filter((name) => TURN.test(name)).map(Number);
+  if (slots.length === 0) return "empty";
+  const slot = Math.max(...slots);
+  const turn = await readTurn(directory, slot);
+  return turn === "damaged" ? slot : turn;
+}
+async function readTurn(directory, slot) {
+  const path = join(directory, String(slot));
+  let text;
+  try {
+    text = await readFile(join(path, "owner.json"), "utf8");
+  } catch (error) {
+    if (!isErrno(error, "ENOENT") && !isErrno(error, "ENOTDIR")) throw error;
+    return await exists(path) ? "damaged" : null;
+  }
+  let owner;
+  try {
+    owner = JSON.parse(text);
+  } catch {
+    return "damaged";
+  }
+  if (owner === null || typeof owner !== "object" || typeof owner.token !== "string" || typeof owner.pid !== "number") {
+    return "damaged";
+  }
+  const done = await exists(join(path, `${owner.token}.done`));
+  const held = await exists(join(path, `${owner.token}.held`));
+  return {
+    slot,
+    token: owner.token,
+    pid: owner.pid,
+    after: typeof owner.after === "string" ? owner.after : null,
+    held,
+    done
+  };
+}
+async function isFinishedTurn(directory, slot, token) {
+  const turn = await readTurn(directory, slot);
+  if (turn === "damaged") throw new Error(`Turn ${slot} of the turn lock ${directory} is unreadable.`);
+  return turn !== null && turn.token === token && turn.held && turn.done;
+}
+async function takeTurn(profile, directory, latest) {
+  const token = randomUUID();
+  const slot = latest.slot + 1;
+  const path = join(directory, String(slot));
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: latest.token };
+  let published = false;
+  try {
+    published = await publishDirectory(
+      join(directory, `.stage-${process.pid}-${token}`),
+      path,
+      { "owner.json": `${JSON.stringify(owner, null, 2)}
+` },
+      () => waitForTestBarrier(TEST_LOCK_TURN_PUBLISH_BARRIER_DIR, profile)
+    );
+    if (published && await isFinishedTurn(directory, latest.slot, latest.token) && await markTurn(path, token, "held")) {
+      return { directory, slot, token };
+    }
+    if (published) await markTurn(path, token, "done");
+    return null;
+  } catch (error) {
+    if (published) settleOwnTurn(directory, slot, token);
+    throw error;
+  }
+}
+async function settleAbandonedTurn(directory, abandoned) {
+  const path = join(directory, String(abandoned.slot));
+  if (!abandoned.held && abandoned.after !== null && await isFinishedTurn(directory, abandoned.slot - 1, abandoned.after)) {
+    await markTurn(path, abandoned.token, "held");
+  }
+  await markTurn(path, abandoned.token, "done");
+}
+function settleOwnTurn(directory, slot, token, retries = SETTLE_RETRIES) {
+  relinquishedTurns.add(token);
+  void (async () => {
+    try {
+      const turn = await readTurn(directory, slot);
+      if (turn !== null && turn !== "damaged" && turn.token === token && !turn.done) await settleAbandonedTurn(directory, turn);
+      relinquishedTurns.delete(token);
+    } catch {
+      if (retries > 0) setTimeout(() => settleOwnTurn(directory, slot, token, retries - 1), SETTLE_RETRY_MS).unref();
+    }
+  })();
+}
+async function markTurn(path, token, kind) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await writeFile(join(path, `${token}.${kind}`), "", { mode: PRIVATE_FILE_MODE, flag: "wx" });
+      return true;
+    } catch (error) {
+      if (isErrno(error, "EEXIST")) return true;
+      if (isErrno(error, "ENOENT")) return false;
+      if (attempt >= MARKER_RETRY_DELAYS_MS.length) throw error;
+      await sleep(MARKER_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+}
+async function createTurnDirectory(directory) {
+  const token = randomUUID();
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token, after: null };
+  await publishDirectory(join(dirname(directory), `.stage-${basename(directory)}-${process.pid}-${token}`), directory, {
+    "0/owner.json": `${JSON.stringify(owner, null, 2)}
+`,
+    [`0/${token}.held`]: "",
+    [`0/${token}.done`]: ""
+  });
+}
+async function publishDirectory(stage, target, files, beforeRename) {
+  try {
+    for (const [name, contents] of Object.entries(files)) {
+      await mkdir(dirname(join(stage, name)), { recursive: true, mode: PRIVATE_DIR_MODE });
+      await writeFileDurably(join(stage, name), contents);
+    }
+    await beforeRename?.();
+    await rename(stage, target);
+    return true;
+  } catch (error) {
+    if (["ENOTEMPTY", "EEXIST", "ENOENT"].some((code) => isErrno(error, code)) || await exists(target)) return false;
+    throw error;
+  } finally {
+    await rm(stage, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function releaseTurn(profile, turn) {
+  try {
+    await markTurn(join(turn.directory, String(turn.slot)), turn.token, "done");
+  } catch {
+    settleOwnTurn(turn.directory, turn.slot, turn.token);
+    return;
+  }
+  await collectTurns(profile, turn).catch(() => void 0);
+}
+function isAbandonedTurnEntry(name) {
+  if (name.startsWith(".trash-")) return true;
+  const writer = /^\.(?:stage|deleted\.json)[-.]([0-9]+)[-.]/.exec(name)?.[1];
+  return writer !== void 0 && !isProcessAlive(Number(writer));
+}
+function isAbandonedTurnDirectoryStage(name) {
+  const writer = /^\.stage-.+-([0-9]+)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.exec(name)?.[1];
+  return writer !== void 0 && !isProcessAlive(Number(writer));
+}
+async function collectTurns(profile, turn) {
+  for (const [directory, abandoned] of [
+    [turn.directory, isAbandonedTurnEntry],
+    [dirname(turn.directory), isAbandonedTurnDirectoryStage]
+  ]) {
+    for (const name of (await readdir(directory)).filter(abandoned)) {
+      await rm(join(directory, name), { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+  const older = (await readdir(turn.directory)).filter((name) => TURN.test(name)).map(Number).filter((slot) => slot < turn.slot).sort((left, right) => left - right);
+  for (const slot of older) {
+    const candidate = await readTurn(turn.directory, slot);
+    if (candidate === null || candidate === "damaged" || !candidate.done) continue;
+    if (candidate.held) {
+      if (await exists(join(turn.directory, String(slot - 1)))) continue;
+      const next = await readTurn(turn.directory, slot + 1);
+      if (next === null || next === "damaged" || !next.held || !next.done) continue;
+    }
+    await waitForTestBarrier(TEST_LOCK_TURN_COLLECT_BARRIER_DIR, profile);
+    const trash = join(turn.directory, `.trash-${randomUUID()}`);
+    if (await rename(join(turn.directory, String(slot)), trash).then(() => true, () => false)) {
+      await rm(trash, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+}
+async function publishProfileLock(profile, lockPath, token) {
+  try {
+    await mkdir(lockPath, { mode: PRIVATE_DIR_MODE });
+  } catch (error) {
+    if (isErrno(error, "EEXIST")) return false;
+    if (!isErrno(error, "ENOENT")) throw error;
+    await mkdir(profilePath(profile), { recursive: true, mode: PRIVATE_DIR_MODE });
+    return false;
+  }
+  await waitForTestBarrier(TEST_LOCK_PUBLISH_BARRIER_DIR, profile);
+  const ownerPath = join(lockPath, "owner.json");
+  const staged = join(dirname(lockPath), `.lock-owner-${token}.tmp`);
+  const owner = `${JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token }, null, 2)}
+`;
+  try {
+    await writeFile(staged, owner, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+    try {
+      await link(staged, ownerPath);
+    } catch (error) {
+      if (!lacksHardLinks(error)) throw error;
+      await writeFile(ownerPath, owner, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+    }
+    return true;
+  } catch (error) {
+    if (isErrno(error, "EEXIST") || isErrno(error, "ENOENT")) return false;
+    await rmdir(lockPath).catch(() => void 0);
+    throw error;
+  } finally {
+    await rm(staged, { force: true }).catch(() => void 0);
+  }
+}
+var NO_HARD_LINK_ERRORS = /* @__PURE__ */ new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EISDIR", "EMLINK"]);
+function lacksHardLinks(error) {
+  return typeof error === "object" && error !== null && "code" in error && NO_HARD_LINK_ERRORS.has(String(error.code));
+}
+async function releaseProfileLock(profile, lockPath, token) {
+  const ownerPath = join(lockPath, "owner.json");
+  const owner = await readJson(ownerPath).catch(() => null);
+  if (owner?.token !== token) return;
+  await rm(ownerPath, { force: true });
+  await waitForTestBarrier(TEST_LOCK_RELEASE_BARRIER_DIR, profile);
+  await rmdir(lockPath).catch(() => void 0);
+}
+async function signalTestLockContention(profile) {
+  if (process.env.NODE_ENV !== "test") return;
+  const configuredPath = process.env[TEST_LOCK_CONTENTION_SIGNAL_PATH];
+  const configuredHome = process.env.TC_HOME;
+  if (!configuredPath || !configuredHome) return;
+  const home = resolve(configuredHome);
+  const signalPath = resolve(configuredPath);
+  const pathFromHome = relative(home, signalPath);
+  if (pathFromHome === "" || pathFromHome === ".." || pathFromHome.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || pathFromHome.startsWith("../") || pathFromHome.startsWith("..\\")) {
+    return;
+  }
+  await writeFile(signalPath, `${profile}
+`, { encoding: "utf8", flag: "wx" }).catch(() => void 0);
+}
+async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
+  let aged;
+  try {
+    const { mtimeMs } = await stat(lockPath);
+    aged = Date.now() - mtimeMs >= staleAfterMs;
+  } catch {
+    return false;
+  }
+  const checkedAt = performance.now();
+  await waitForTestBarrier(TEST_LOCK_OWNERLESS_BARRIER_DIR, profile);
+  try {
+    const entries = await readdir(lockPath);
+    if (entries.includes("owner.json")) return false;
+    const onlyOrphanedClaims = entries.length > 0 && entries.every((entry) => RECOVERY_CLAIM.test(entry));
+    if (!onlyOrphanedClaims && (!aged || recoveryFenced(checkedAt, staleAfterMs))) return false;
+    for (const name of entries.filter((entry) => RECOVERY_CLAIM.test(entry))) {
+      const claimPath = join(lockPath, name);
+      if (await hasLiveRecoveryOwner(claimPath)) {
+        if (!await exists(join(lockPath, "owner.json"))) await rename(claimPath, join(lockPath, "owner.json"));
+        return false;
+      }
+      await rm(claimPath, { force: true });
+    }
+    for (const name of entries.filter((entry) => ABANDONED_CLAIM.test(entry))) {
+      await rm(join(lockPath, name), { force: true });
+    }
+    await rmdir(lockPath);
+  } catch {
+    return false;
+  }
+  await removeAgedOwnerFiles(lockPath, staleAfterMs);
+  return true;
+}
+async function hasLiveRecoveryOwner(claimPath) {
+  let contents;
+  try {
+    contents = await readFile(claimPath, "utf8");
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return false;
+    throw error;
+  }
+  let owner;
+  try {
+    owner = JSON.parse(contents);
+  } catch {
+    return false;
+  }
+  const pid = typeof owner === "object" && owner !== null && "pid" in owner ? owner.pid : null;
+  return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && isProcessAlive(pid);
+}
+function recoveryFenced(since, staleAfterMs) {
+  return performance.now() - since >= staleAfterMs / 2;
+}
+var ABANDONED_CLAIM = /^\.(?:release|stale)-[0-9a-f-]+\.json$/;
+var RECOVERY_CLAIM = /^\.recover-[0-9a-f-]+\.json$/;
+var STAGED_OWNER = /^\.lock-owner-[0-9a-f-]+\.tmp$/;
+async function removeAgedOwnerFiles(lockPath, staleAfterMs) {
+  const directory = dirname(lockPath);
+  const names = await readdir(directory).catch(() => []);
+  for (const name of names.filter((entry) => STAGED_OWNER.test(entry))) {
+    const path = join(directory, name);
+    const aged = await stat(path).then(({ mtimeMs }) => Date.now() - mtimeMs >= staleAfterMs, () => false);
+    if (aged) await rm(path, { force: true }).catch(() => void 0);
+  }
+}
+async function recoverStaleLock(profile, lockPath, staleAfterMs) {
+  const ownerPath = join(lockPath, "owner.json");
+  const observed = await readFile(ownerPath, "utf8").catch(() => null);
+  if (observed === null) return recoverOwnerlessLock(profile, lockPath, staleAfterMs);
+  if (!await isAbandonedOwner(observed, ownerPath, staleAfterMs)) return false;
+  await waitForTestBarrier(TEST_LOCK_RECOVERY_BARRIER_DIR, profile);
+  const claimPath = join(lockPath, `.recover-${randomUUID()}.json`);
+  let moved = false;
+  try {
+    await link(ownerPath, claimPath);
+  } catch (error) {
+    if (!lacksHardLinks(error)) return false;
+    try {
+      await rename(ownerPath, claimPath);
+      moved = true;
+    } catch {
+      return false;
+    }
+  }
+  if (moved) await waitForTestBarrier(TEST_LOCK_MOVED_BARRIER_DIR, profile);
+  const sameInstance = await readFile(claimPath, "utf8").then((claimed) => claimed === observed, () => false);
+  await waitForTestBarrier(TEST_LOCK_VERIFIED_BARRIER_DIR, profile);
+  if (!sameInstance) {
+    if (moved) {
+      await rename(claimPath, ownerPath).catch(() => void 0);
+    } else {
+      await unlink(claimPath).catch(() => void 0);
+    }
+    return false;
+  }
+  if (!moved) await rm(ownerPath, { force: true });
+  await waitForTestBarrier(TEST_LOCK_CLAIM_BARRIER_DIR, profile);
+  await waitForTestBarrier(TEST_LOCK_CLAIMED_BARRIER_DIR, profile);
+  for (const name of (await readdir(lockPath).catch(() => [])).filter((entry) => RECOVERY_CLAIM.test(entry))) {
+    if (join(lockPath, name) !== claimPath) await rm(join(lockPath, name), { force: true });
+  }
+  if (await unlink(claimPath).then(() => true, () => false)) await rmdir(lockPath).catch(() => void 0);
+  await removeAgedOwnerFiles(lockPath, staleAfterMs);
+  return true;
+}
+async function isAbandonedOwner(observed, ownerPath, staleAfterMs) {
+  let owner;
+  try {
+    owner = JSON.parse(observed);
+  } catch {
+    owner = null;
+  }
+  if (typeof owner === "object" && owner !== null && "pid" in owner) {
+    return isStaleOwner(owner, staleAfterMs);
+  }
+  const modifiedAt = await stat(ownerPath).then(({ mtimeMs }) => mtimeMs, () => Number.NaN);
+  return Date.now() - modifiedAt >= staleAfterMs;
+}
+async function waitForTestBarrier(environmentName, profile) {
+  if (process.env.NODE_ENV !== "test") return;
+  const barrierDirectory = process.env[environmentName];
+  if (!barrierDirectory) return;
+  await mkdir(barrierDirectory, { recursive: true });
+  const readyPath = join(barrierDirectory, `ready-${process.pid}-${profile}`);
+  await writeFile(readyPath, "ready\n", { encoding: "utf8", flag: "wx" }).catch(() => void 0);
+  const releasePath = join(barrierDirectory, "release");
+  while (true) {
+    try {
+      await readFile(releasePath, "utf8");
+      return;
+    } catch {
+      await sleep(1);
+    }
+  }
+}
+function isStaleOwner(owner, staleAfterMs) {
+  const now = Date.now();
+  const createdAt = typeof owner?.createdAt === "string" ? Date.parse(owner.createdAt) : Number.NaN;
+  if (!Number.isFinite(createdAt) || now - createdAt < staleAfterMs) return false;
+  if (typeof owner?.pid !== "number" || !Number.isInteger(owner.pid) || owner.pid <= 0) {
+    return false;
+  }
+  return !isProcessAlive(owner.pid);
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isErrno(error, "ENOENT") || isErrno(error, "ENOTDIR")) return false;
+    throw error;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !isErrno(error, "ESRCH");
+  }
+}
+function validateProfileName(profile) {
+  if (!profile || profile === "." || profile === ".." || profile.includes("/") || profile.includes("\\") || profile.includes("\0")) {
+    throw new TypeError("Profile names must be non-empty path segments.");
+  }
+  return profile;
+}
+function isErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function sleep(milliseconds) {
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+
+// src/artifacts.ts
+var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+var PermissionEntrySchema = z.object({
+  service: z.string().min(1),
+  space: z.string().min(1).optional(),
+  path: z.string(),
+  actions: z.array(z.string().min(1)).min(1),
+  caveats: z.array(z.record(z.unknown())).optional(),
+  skipPrefix: z.boolean().optional(),
+  expiry: z.string().min(1).optional(),
+  description: z.string().optional()
+}).strict();
+var CommandSchema = z.object({
+  argv: z.array(z.string()).min(1),
+  cwd: z.string().min(1)
+}).strict();
+var LegacyPermissionRequestArtifactSchema = z.object({
+  kind: z.literal("tinycloud.auth.request"),
+  version: z.literal(1),
+  requestId: z.string(),
+  sessionDid: z.string().min(1),
+  requested: z.array(PermissionEntrySchema),
+  requestedExpiry: z.union([z.string(), z.number().finite()]).optional()
+}).strict();
+var PortableDelegationSchema = z.lazy(() => z.object({
+  cid: z.string().min(1),
+  spaceId: z.string().min(1),
+  path: z.string(),
+  actions: z.array(z.string().min(1)).min(1),
+  delegateDID: z.string().min(1),
+  ownerAddress: z.string().min(1),
+  chainId: z.number().int().positive(),
+  expiry: z.union([z.string().datetime({ offset: true }), z.date()]),
+  delegationHeader: z.object({ Authorization: z.string().min(1) }).strict(),
+  host: z.string().min(1).optional(),
+  disableSubDelegation: z.boolean().optional(),
+  publicDelegation: PortableDelegationSchema.optional(),
+  resources: z.array(PermissionEntrySchema).optional()
+}).passthrough());
+var PermissionRequestArtifactSchema = z.object({
+  kind: z.literal("tinycloud.auth.request"),
+  version: z.literal(1),
+  requestId: z.string().min(1),
+  createdAt: z.string().datetime({ offset: true }),
+  profile: z.string().min(1),
+  posture: z.enum(["owner-openkey", "delegate-session", "local-owner-key", "unauthenticated"]),
+  operatorType: z.enum(["human", "agent"]),
+  host: z.string().min(1),
+  sessionDid: z.string().min(1),
+  ownerDid: z.string().min(1).optional(),
+  spaceId: z.string().min(1).optional(),
+  requestedExpiry: z.union([z.string().min(1), z.number().finite()]).optional(),
+  requested: z.array(PermissionEntrySchema),
+  command: CommandSchema.optional()
+}).strict();
+var DelegationImportArtifactSchema = z.object({
+  kind: z.literal("tinycloud.auth.delegation"),
+  version: z.literal(1),
+  requestId: z.string().min(1),
+  delegationCid: z.string().min(1).optional(),
+  delegation: PortableDelegationSchema,
+  // This field is presentation metadata only. A later import operation obtains
+  // effective permissions from validated, installed delegation authority.
+  permissions: z.array(PermissionEntrySchema).optional(),
+  expiry: z.string().datetime({ offset: true }).optional(),
+  prompted: z.boolean().optional()
+}).strict();
+var DelegationRequestBindingSchema = PermissionRequestArtifactSchema.pick({ requestId: true, requested: true }).strict();
+
+// src/secrets.ts
+import * as nodeSdk from "@tinycloud/node-sdk";
+
+// src/errors.ts
+function operationError(code, message, options = {}) {
+  return {
+    code,
+    message,
+    retryable: options.retryable ?? false,
+    ...options.details === void 0 ? {} : { details: options.details }
+  };
+}
+var OperationInvocationError = class extends Error {
+  constructor(operationError2) {
+    super(operationError2.message);
+    this.name = "OperationInvocationError";
+    this.operationError = operationError2;
+  }
+};
+
+// src/secrets.ts
+function operationSpaceResolver(node, ownerSpace) {
+  return (space) => resolveOperationSpace(space, node, ownerSpace);
+}
+function resolveOperationSpace(space, node, ownerSpace) {
+  if (space.startsWith("tinycloud:")) return canonicalizeSpaceUri(space);
+  const ownerSpaceId = ownerSpace === void 0 ? void 0 : ownedSpaceForName(ownerSpace, space);
+  if (ownerSpaceId !== void 0) return canonicalizeSpaceUri(ownerSpaceId);
+  const candidate = node;
+  try {
+    const resolved = candidate.resolveOwnedSpace?.(space);
+    if (typeof resolved === "string" && resolved.length > 0) {
+      return canonicalizeSpaceUri(resolved);
+    }
+  } catch {
+  }
+  if (typeof candidate.spaceId === "string") {
+    const resolved = ownedSpaceForName(candidate.spaceId, space);
+    if (resolved !== void 0) return canonicalizeSpaceUri(resolved);
+  }
+  const did = typeof candidate.did === "string" ? candidate.did : void 0;
+  const pkh = did === void 0 ? null : nodeSdk.parsePkhDid(did);
+  if (pkh === null) {
+    throw invalidSecretInput();
+  }
+  return nodeSdk.makePkhSpaceId(pkh.address, pkh.chainId, space);
+}
+function ownedSpaceForName(ownerSpace, name) {
+  const parsed = nodeSdk.parseSpaceUri(ownerSpace);
+  if (parsed === null) return void 0;
+  try {
+    const pkh = nodeSdk.parsePkhDid(parsed.owner);
+    return pkh === null ? void 0 : nodeSdk.makePkhSpaceId(pkh.address, pkh.chainId, name);
+  } catch {
+    return void 0;
+  }
+}
+function canonicalizeSpaceUri(space) {
+  const parts = space.split(":");
+  const name = parts.at(-1);
+  if (parts.length < 3 || name === void 0 || name === "") {
+    throw invalidSecretInput();
+  }
+  const pkh = space.match(
+    /^tinycloud:pkh:eip155:(\d+):(0x[0-9a-fA-F]{40}):([^:]+)$/
+  );
+  if (pkh !== null) {
+    return `tinycloud:pkh:eip155:${pkh[1]}:${nodeSdk.canonicalizeAddress(pkh[2]).toLowerCase()}:${pkh[3]}`;
+  }
+  return space;
+}
+function invalidSecretInput() {
+  return new OperationInvocationError(
+    operationError("INPUT_INVALID", "The secret reference is invalid.")
+  );
+}
+
+// src/delegation-binding.ts
+var REQUEST_ID_PREFIX = {
+  migration: "migrated",
+  "unbound-import": "unbound-import"
+};
+var BINDING_NOTES = {
+  migration: "Stored without a request binding before bindings were required. Bound at migration to exactly its own signed capabilities, so replay refuses any delegation in this record that exceeds them.",
+  "unbound-import": "Imported by `tc auth import` without a stored request. Bound to exactly its own signed capabilities, so replay refuses any delegation in this record that exceeds them."
+};
+var MIGRATION_LOCK_TIMEOUT_MS = 250;
+function bindingMigrationPath(profile) {
+  return join2(profilePath(profile), "delegation-binding-migration.json");
+}
+function storedDelegationKind(entry) {
+  if (!isRecord(entry)) return "refused";
+  const delegation = entry.delegation;
+  if (!isRecord(delegation)) return "refused";
+  const header = delegation.delegationHeader;
+  if (!isRecord(header) || Object.keys(header).length !== 1 || !Object.prototype.hasOwnProperty.call(header, "Authorization") || typeof header.Authorization !== "string") {
+    return "refused";
+  }
+  if ("siweProof" in delegation) return "signed-login";
+  if (header.Authorization.includes(".")) return "compact";
+  return "authorityRequest" in entry ? "refused" : "other";
+}
+function replayLimit(entry, migrated) {
+  const kind = storedDelegationKind(entry);
+  if (!isRecord(entry) || kind !== "compact" && kind !== "signed-login") return void 0;
+  const binding = DelegationRequestBindingSchema.safeParse(entry.authorityRequest);
+  if (binding.success) return binding.data.requested;
+  return !migrated && kind === "compact" && !("authorityRequest" in entry) ? "signed" : void 0;
+}
+function bindToSignedCapabilities(record, signed, source, recordedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    ...record,
+    authorityRequest: DelegationRequestBindingSchema.parse({
+      requestId: `${REQUEST_ID_PREFIX[source]}:${record.delegation.cid}`,
+      requested: structuredClone(signed)
+    }),
+    authorityRequestAudit: { source, recordedAt, note: BINDING_NOTES[source] }
+  };
+}
+async function activateUnboundCompactImport(node, delegation, host) {
+  const activated = await nodeSdk2.activateValidatedRuntimeDelegation(node, delegation, { host });
+  return bindToSignedCapabilities(
+    // The record keeps the delegation as imported; replay validates it again.
+    { delegation, permissions: [...activated.effectivePermissions] },
+    activated.effectivePermissions,
+    "unbound-import"
+  );
+}
+function mergeDelegationsWithoutRequest(stored, incoming) {
+  let records = [...stored];
+  for (const record of incoming) {
+    const cid = record.delegation.cid;
+    if (records.some((entry) => storedCid(entry) === cid && isRecord(entry) && "authorityRequest" in entry)) continue;
+    const position = records.findIndex((entry) => storedCid(entry) === cid);
+    const others = records.filter((entry) => storedCid(entry) !== cid);
+    records = position === -1 ? [...records, record] : [...others.slice(0, position), record, ...others.slice(position)];
+  }
+  return records;
+}
+async function prepareStoredDelegationReplay(profile, node, options) {
+  if (await bindingMigrationRecorded(profile)) return true;
+  if (!options.migrate || !await holdsPersistedSession(profile, node)) return false;
+  try {
+    return await withProfileLock(profile, async () => {
+      if (await bindingMigrationRecorded(profile)) return true;
+      if (!await holdsPersistedSession(profile, node)) return false;
+      const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const bound = /* @__PURE__ */ new Map();
+      const unbound = [];
+      for (const entry of await readAdditionalDelegations(profile)) {
+        if (!isRecord(entry) || "authorityRequest" in entry || storedDelegationKind(entry) !== "compact") continue;
+        const migrated = await migratedRecord(node, entry, options.host, recordedAt);
+        if (migrated === void 0) unbound.push(String(storedCid(entry)));
+        else bound.set(recordKey(entry), migrated);
+      }
+      if (bound.size > 0) {
+        await updateProfileStore(profile, "additional-delegations", (records) => ({
+          records: records.map((entry) => {
+            const key = !isRecord(entry) || "authorityRequest" in entry ? void 0 : recordKey(entry);
+            return (key === void 0 ? void 0 : bound.get(key)) ?? entry;
+          }),
+          result: void 0
+        }));
+      }
+      await writeJsonAtomic(bindingMigrationPath(profile), {
+        formatVersion: 1,
+        migratedAt: recordedAt,
+        bound: [...bound.values()].map(storedCid),
+        unbound
+      });
+      return true;
+    }, { timeoutMs: MIGRATION_LOCK_TIMEOUT_MS });
+  } catch {
+    return false;
+  }
+}
+async function holdsPersistedSession(profile, node) {
+  try {
+    const persisted = await readSession(profile);
+    return typeof persisted?.verificationMethod === "string" && typeof node.sessionDid === "string" && persisted.verificationMethod.split("#", 1)[0] === node.sessionDid.split("#", 1)[0];
+  } catch {
+    return false;
+  }
+}
+async function migratedRecord(node, entry, host, recordedAt) {
+  const delegation = normalizeStoredDelegation(entry);
+  if (delegation === void 0) return void 0;
+  const signed = await signedCapabilities(node, delegation, host);
+  if (signed === void 0) return void 0;
+  try {
+    return bindToSignedCapabilities({ ...entry, delegation: { ...entry.delegation, cid: delegation.cid } }, signed, "migration", recordedAt);
+  } catch {
+    return void 0;
+  }
+}
+async function replayStoredDelegation(node, entry, options) {
+  const delegation = normalizeStoredDelegation(entry);
+  if (delegation === void 0 || delegation.expiry.getTime() <= Date.now()) return void 0;
+  const limit = replayLimit(entry, options.migrated);
+  if (limit === void 0) return void 0;
+  const authorize = limit === "signed" ? () => true : (effective) => delegationWithinRequest(limit, effective, options.resolveSpace);
+  try {
+    return await nodeSdk2.activateValidatedRuntimeDelegation(node, delegation, { host: options.host, authorize });
+  } catch {
+    return void 0;
+  }
+}
+async function bindingMigrationRecorded(profile) {
+  try {
+    return await readJson(bindingMigrationPath(profile)) !== null;
+  } catch {
+    return true;
+  }
+}
+async function signedCapabilities(node, delegation, host) {
+  let signed;
+  try {
+    await nodeSdk2.activateValidatedRuntimeDelegation(node, delegation, {
+      // The transport host is not signed authority; check it at replay instead.
+      host: delegation.host ?? host,
+      authorize: (effective) => {
+        signed = effective;
+        return false;
+      }
+    });
+  } catch {
+  }
+  return signed;
+}
+function normalizeStoredDelegation(entry) {
+  if (!isRecord(entry)) return void 0;
+  const raw = entry.delegation;
+  if (!isRecord(raw) || !isRecord(raw.delegationHeader)) return void 0;
+  const expiry = raw.expiry instanceof Date ? raw.expiry : typeof raw.expiry === "string" ? new Date(raw.expiry) : void 0;
+  if (expiry === void 0 || Number.isNaN(expiry.getTime()) || typeof raw.cid !== "string" || typeof raw.spaceId !== "string" || typeof raw.path !== "string" || !Array.isArray(raw.actions) || !raw.actions.every((action) => typeof action === "string") || typeof raw.delegateDID !== "string" || typeof raw.ownerAddress !== "string" || typeof raw.chainId !== "number" || typeof raw.delegationHeader.Authorization !== "string") {
+    return void 0;
+  }
+  return { ...raw, expiry };
+}
+function storedCid(entry) {
+  const cid = isRecord(entry) && isRecord(entry.delegation) ? entry.delegation.cid : void 0;
+  return typeof cid === "string" ? cid : void 0;
+}
+function recordKey(entry) {
+  const delegation = entry.delegation;
+  if (!isRecord(delegation) || !isRecord(delegation.delegationHeader)) return void 0;
+  return JSON.stringify([delegation.cid, delegation.delegationHeader.Authorization]);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  BINDING_NOTES,
+  activateUnboundCompactImport,
+  bindingMigrationPath,
+  bindingMigrationRecorded,
+  mergeDelegationsWithoutRequest,
+  operationSpaceResolver,
+  prepareStoredDelegationReplay,
+  replayLimit,
+  replayStoredDelegation,
+  storedDelegationKind
+};
+//# sourceMappingURL=delegation-binding.js.map