@sledorze/cairn 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1147,14 +1147,14 @@ var require_util = __commonJS({
         }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
         let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
-        let path12 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
+        let path14 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path12 && path12[0] !== "/") {
-          path12 = `/${path12}`;
+        if (path14 && path14[0] !== "/") {
+          path14 = `/${path14}`;
         }
-        return new URL(`${origin}${path12}`);
+        return new URL(`${origin}${path14}`);
       }
       if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -2025,9 +2025,9 @@ var require_diagnostics = __commonJS({
         "undici:client:sendHeaders",
         (evt) => {
           const {
-            request: { method, path: path12, origin }
+            request: { method, path: path14, origin }
           } = evt;
-          debugLog("sending request to %s %s%s", method, origin, path12);
+          debugLog("sending request to %s %s%s", method, origin, path14);
         }
       );
     }
@@ -2045,14 +2045,14 @@ var require_diagnostics = __commonJS({
         "undici:request:headers",
         (evt) => {
           const {
-            request: { method, path: path12, origin },
+            request: { method, path: path14, origin },
             response: { statusCode }
           } = evt;
           debugLog(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
-            path12,
+            path14,
             statusCode
           );
         }
@@ -2061,23 +2061,23 @@ var require_diagnostics = __commonJS({
         "undici:request:trailers",
         (evt) => {
           const {
-            request: { method, path: path12, origin }
+            request: { method, path: path14, origin }
           } = evt;
-          debugLog("trailers received from %s %s%s", method, origin, path12);
+          debugLog("trailers received from %s %s%s", method, origin, path14);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:request:error",
         (evt) => {
           const {
-            request: { method, path: path12, origin },
+            request: { method, path: path14, origin },
             error: error2
           } = evt;
           debugLog(
             "request to %s %s%s errored - %s",
             method,
             origin,
-            path12,
+            path14,
             error2.message
           );
         }
@@ -2232,7 +2232,7 @@ var require_request = __commonJS({
     };
     var Request = class {
       constructor(origin, {
-        path: path12,
+        path: path14,
         method,
         body,
         headers,
@@ -2249,11 +2249,11 @@ var require_request = __commonJS({
         maxRedirections,
         typeOfService
       }, handler) {
-        if (typeof path12 !== "string") {
+        if (typeof path14 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path12[0] !== "/" && !(path12.startsWith("http://") || path12.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path14[0] !== "/" && !(path14.startsWith("http://") || path14.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path12)) {
+        } else if (invalidPathRegex.test(path14)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -2328,7 +2328,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? serializePathWithQuery(path12, query) : path12;
+        this.path = query ? serializePathWithQuery(path14, query) : path14;
         this.origin = origin;
         this.protocol = getProtocolFromUrlString(origin);
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" || method === "QUERY" : idempotent;
@@ -7394,7 +7394,7 @@ var require_client_h1 = __commonJS({
       }
     }
     function writeH1(client, request3) {
-      const { method, path: path12, host, upgrade, blocking, reset: reset2 } = request3;
+      const { method, path: path14, host, upgrade, blocking, reset: reset2 } = request3;
       let { body, headers, contentLength } = request3;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
@@ -7462,7 +7462,7 @@ var require_client_h1 = __commonJS({
         socket[kBlocking] = true;
       }
       setTypeOfService(socket, request3);
-      let header = `${method} ${path12} HTTP/1.1\r
+      let header = `${method} ${path14} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -8471,7 +8471,7 @@ var require_client_h2 = __commonJS({
       const headersTimeout = request3.headersTimeout ?? client[kHeadersTimeout];
       const bodyTimeout = request3.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path12, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request3;
+      const { method, path: path14, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request3;
       if (upgrade != null && upgrade !== "websocket") {
         util.errorRequest(client, request3, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
         return false;
@@ -8534,7 +8534,7 @@ var require_client_h2 = __commonJS({
           }
           headers[HTTP2_HEADER_METHOD] = "CONNECT";
           headers[HTTP2_HEADER_PROTOCOL] = "websocket";
-          headers[HTTP2_HEADER_PATH] = path12;
+          headers[HTTP2_HEADER_PATH] = path14;
           if (protocol === "ws:" || protocol === "wss:") {
             headers[HTTP2_HEADER_SCHEME] = protocol === "ws:" ? "http" : "https";
           } else {
@@ -8556,7 +8556,7 @@ var require_client_h2 = __commonJS({
         setupUpgradeStream(stream2, state);
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path12;
+      headers[HTTP2_HEADER_PATH] = path14;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       let body = state.body;
@@ -11151,10 +11151,10 @@ var require_proxy_agent = __commonJS({
         };
         const {
           origin,
-          path: path12 = "/",
+          path: path14 = "/",
           headers = {}
         } = opts;
-        opts.path = origin + path12;
+        opts.path = origin + path14;
         if (!("host" in headers) && !("Host" in headers)) {
           const { host } = new URL(origin);
           headers.host = host;
@@ -13399,20 +13399,20 @@ var require_mock_utils = __commonJS({
       }
       return normalizedQp;
     }
-    function safeUrl(path12) {
-      if (typeof path12 !== "string") {
-        return path12;
+    function safeUrl(path14) {
+      if (typeof path14 !== "string") {
+        return path14;
       }
-      const pathSegments = path12.split("?", 3);
+      const pathSegments = path14.split("?", 3);
       if (pathSegments.length !== 2) {
-        return path12;
+        return path14;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path12, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path12);
+    function matchKey(mockDispatch2, { path: path14, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path14);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -13437,8 +13437,8 @@ var require_mock_utils = __commonJS({
       const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
       const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path12, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path12)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path12), resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path14, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path14)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path14), resolvedPath);
       });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
@@ -13477,19 +13477,19 @@ var require_mock_utils = __commonJS({
         mockDispatches.splice(index2, 1);
       }
     }
-    function removeTrailingSlash(path12) {
-      while (path12.endsWith("/")) {
-        path12 = path12.slice(0, -1);
+    function removeTrailingSlash(path14) {
+      while (path14.endsWith("/")) {
+        path14 = path14.slice(0, -1);
       }
-      if (path12.length === 0) {
-        path12 = "/";
+      if (path14.length === 0) {
+        path14 = "/";
       }
-      return path12;
+      return path14;
     }
     function buildKey(opts) {
-      const { path: path12, method, body, headers, query } = opts;
+      const { path: path14, method, body, headers, query } = opts;
       return {
-        path: path12,
+        path: path14,
         method,
         body,
         headers,
@@ -14219,10 +14219,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path12, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path14, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path12,
+            Path: path14,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -14304,9 +14304,9 @@ var require_mock_agent = __commonJS({
         const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
         const dispatchOpts = { ...opts };
         if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path12, searchParams] = dispatchOpts.path.split("?");
+          const [path14, searchParams] = dispatchOpts.path.split("?");
           const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path12}?${normalizedSearchParams}`;
+          dispatchOpts.path = `${path14}?${normalizedSearchParams}`;
         }
         return this[kAgent].dispatch(dispatchOpts, handler);
       }
@@ -14722,12 +14722,12 @@ var require_snapshot_recorder = __commonJS({
        * @return {Promise<void>} - Resolves when snapshots are loaded
        */
       async loadSnapshots(filePath) {
-        const path12 = filePath || this.#snapshotPath;
-        if (!path12) {
+        const path14 = filePath || this.#snapshotPath;
+        if (!path14) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile3(resolve5(path12), "utf8");
+          const data = await readFile3(resolve5(path14), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -14741,7 +14741,7 @@ var require_snapshot_recorder = __commonJS({
           if (error2.code === "ENOENT") {
             this.#snapshots.clear();
           } else {
-            throw new UndiciError(`Failed to load snapshots from ${path12}`, { cause: error2 });
+            throw new UndiciError(`Failed to load snapshots from ${path14}`, { cause: error2 });
           }
         }
       }
@@ -14752,11 +14752,11 @@ var require_snapshot_recorder = __commonJS({
        * @returns {Promise<void>} - Resolves when snapshots are saved
        */
       async saveSnapshots(filePath) {
-        const path12 = filePath || this.#snapshotPath;
-        if (!path12) {
+        const path14 = filePath || this.#snapshotPath;
+        if (!path14) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve5(path12);
+        const resolvedPath = resolve5(path14);
         await mkdir2(dirname4(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash3, snapshot]) => ({
           hash: hash3,
@@ -15378,15 +15378,15 @@ var require_redirect_handler = __commonJS({
           return;
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path12 = search ? `${pathname}${search}` : pathname;
-        const redirectUrlString = `${origin}${path12}`;
+        const path14 = search ? `${pathname}${search}` : pathname;
+        const redirectUrlString = `${origin}${path14}`;
         for (const historyUrl of this.history) {
           if (historyUrl.toString() === redirectUrlString) {
             throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`);
           }
         }
         this.opts.headers = cleanRequestHeaders(this.opts.headers, removeContentHeaders, this.opts.origin !== origin, this.stripHeadersOnRedirect, this.stripHeadersOnCrossOriginRedirect);
-        this.opts.path = path12;
+        this.opts.path = path14;
         this.opts.origin = origin;
         this.opts.query = null;
       }
@@ -17183,13 +17183,13 @@ var require_cache_handler = __commonJS({
           if (url.origin !== requestUrl.origin) {
             continue;
           }
-          const path12 = `${url.pathname}${url.search}`;
-          if (invalidatedPaths.has(path12)) {
+          const path14 = `${url.pathname}${url.search}`;
+          if (invalidatedPaths.has(path14)) {
             continue;
           }
-          invalidatedPaths.add(path12);
+          invalidatedPaths.add(path14);
           try {
-            this.#store.delete({ ...this.#cacheKey, path: path12 })?.catch?.(noop);
+            this.#store.delete({ ...this.#cacheKey, path: path14 })?.catch?.(noop);
           } catch {
           }
         }
@@ -21819,13 +21819,13 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request3);
         const agent = fetchParams.controller.dispatcher;
-        const path12 = url.pathname + url.search;
+        const path14 = url.pathname + url.search;
         const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
         return dispatchWithProtocolPreference(body);
         function dispatchWithProtocolPreference(body2, allowH2) {
           return new Promise((resolve5, reject) => agent.dispatch(
             {
-              path: hasTrailingQuestionMark ? `${path12}?` : path12,
+              path: hasTrailingQuestionMark ? `${path14}?` : path14,
               origin: url.origin,
               method: request3.method,
               body: agent.isMockActive ? request3.body && (request3.body.source || request3.body.stream) : body2,
@@ -22737,9 +22737,9 @@ var require_util4 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path12) {
-      for (let i = 0; i < path12.length; ++i) {
-        const code = path12.charCodeAt(i);
+    function validateCookiePath(path14) {
+      for (let i = 0; i < path14.length; ++i) {
+        const code = path14.charCodeAt(i);
         if (code < 32 || // exclude CTLs (0-31)
         code > 126 || // exclude non-ascii and DEL
         code === 59) {
@@ -26057,11 +26057,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path12 = opts.path;
+          let path14 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path12 = `/${path12}`;
+            path14 = `/${path14}`;
           }
-          url = new URL(util.parseOrigin(url).origin + path12);
+          url = new URL(util.parseOrigin(url).origin + path14);
         } else {
           if (!opts) {
             opts = typeof url === "object" ? url : {};
@@ -31131,20 +31131,20 @@ var require_compiler = __commonJS({
         obj[lastKey] = value3;
       }
       function setPath(node) {
-        var path12 = node.value;
-        var quotedPath = path12.map(quoteDottedString).join(".");
+        var path14 = node.value;
+        var quotedPath = path14.map(quoteDottedString).join(".");
         var off = node.offset;
         if (assignedPaths.has(quotedPath)) {
-          genError("Cannot redefine existing key '" + path12 + "'.", off);
+          genError("Cannot redefine existing key '" + path14 + "'.", off);
         }
         assignedPaths.add(quotedPath);
         explicitTablePaths.add(quotedPath);
-        context4 = deepRef(data, path12, createTable(), off);
-        currentPath = path12;
+        context4 = deepRef(data, path14, createTable(), off);
+        currentPath = path14;
       }
       function addTableArray(node) {
-        var path12 = node.value;
-        var quotedPath = path12.map(quoteDottedString).join(".");
+        var path14 = node.value;
+        var quotedPath = path14.map(quoteDottedString).join(".");
         var off = node.offset;
         if (valueAssignments.has(quotedPath)) {
           genError("Cannot append to statically defined array '" + quotedPath + "'.", off);
@@ -31156,14 +31156,14 @@ var require_compiler = __commonJS({
           if (isSameOrSubPath(p, quotedPath)) valueAssignments.delete(p);
         });
         assignedPaths.add(quotedPath);
-        context4 = deepRef(data, path12, createTableArray(), off);
-        currentPath = path12;
+        context4 = deepRef(data, path14, createTableArray(), off);
+        currentPath = path14;
         if (context4 instanceof Array) {
           var newObj = createTable();
           context4.push(newObj);
           context4 = newObj;
         } else {
-          genError("Cannot redefine existing key '" + path12 + "'.", off);
+          genError("Cannot redefine existing key '" + path14 + "'.", off);
         }
       }
       function deepRef(start, keys3, value3, off) {
@@ -31227,8 +31227,8 @@ var require_compiler = __commonJS({
       function makeFullPath(keys3) {
         return pathKey(currentPath.concat(keys3));
       }
-      function isSameOrSubPath(path12, prefix) {
-        return path12 === prefix || path12.indexOf(prefix + ".") === 0;
+      function isSameOrSubPath(path14, prefix) {
+        return path14 === prefix || path14.indexOf(prefix + ".") === 0;
       }
     }
     module.exports = {
@@ -31329,17 +31329,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path12) {
-      const ctrl = callVisitor(key, node, visitor, path12);
+    function visit_(key, node, visitor, path14) {
+      const ctrl = callVisitor(key, node, visitor, path14);
       if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visit_(key, ctrl, visitor, path12);
+        replaceNode(key, path14, ctrl);
+        return visit_(key, ctrl, visitor, path14);
       }
       if (typeof ctrl !== "symbol") {
         if (identity2.isCollection(node)) {
-          path12 = Object.freeze(path12.concat(node));
+          path14 = Object.freeze(path14.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path12);
+            const ci = visit_(i, node.items[i], visitor, path14);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -31350,13 +31350,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity2.isPair(node)) {
-          path12 = Object.freeze(path12.concat(node));
-          const ck = visit_("key", node.key, visitor, path12);
+          path14 = Object.freeze(path14.concat(node));
+          const ck = visit_("key", node.key, visitor, path14);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path12);
+          const cv = visit_("value", node.value, visitor, path14);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -31377,17 +31377,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path12) {
-      const ctrl = await callVisitor(key, node, visitor, path12);
+    async function visitAsync_(key, node, visitor, path14) {
+      const ctrl = await callVisitor(key, node, visitor, path14);
       if (identity2.isNode(ctrl) || identity2.isPair(ctrl)) {
-        replaceNode(key, path12, ctrl);
-        return visitAsync_(key, ctrl, visitor, path12);
+        replaceNode(key, path14, ctrl);
+        return visitAsync_(key, ctrl, visitor, path14);
       }
       if (typeof ctrl !== "symbol") {
         if (identity2.isCollection(node)) {
-          path12 = Object.freeze(path12.concat(node));
+          path14 = Object.freeze(path14.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path12);
+            const ci = await visitAsync_(i, node.items[i], visitor, path14);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -31398,13 +31398,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity2.isPair(node)) {
-          path12 = Object.freeze(path12.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path12);
+          path14 = Object.freeze(path14.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path14);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path12);
+          const cv = await visitAsync_("value", node.value, visitor, path14);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -31431,23 +31431,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path12) {
+    function callVisitor(key, node, visitor, path14) {
       if (typeof visitor === "function")
-        return visitor(key, node, path12);
+        return visitor(key, node, path14);
       if (identity2.isMap(node))
-        return visitor.Map?.(key, node, path12);
+        return visitor.Map?.(key, node, path14);
       if (identity2.isSeq(node))
-        return visitor.Seq?.(key, node, path12);
+        return visitor.Seq?.(key, node, path14);
       if (identity2.isPair(node))
-        return visitor.Pair?.(key, node, path12);
+        return visitor.Pair?.(key, node, path14);
       if (identity2.isScalar(node))
-        return visitor.Scalar?.(key, node, path12);
+        return visitor.Scalar?.(key, node, path14);
       if (identity2.isAlias(node))
-        return visitor.Alias?.(key, node, path12);
+        return visitor.Alias?.(key, node, path14);
       return void 0;
     }
-    function replaceNode(key, path12, node) {
-      const parent = path12[path12.length - 1];
+    function replaceNode(key, path14, node) {
+      const parent = path14[path14.length - 1];
       if (identity2.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity2.isPair(parent)) {
@@ -32057,10 +32057,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity2 = require_identity();
     var Node2 = require_Node();
-    function collectionFromPath(schema, path12, value3) {
+    function collectionFromPath(schema, path14, value3) {
       let v = value3;
-      for (let i = path12.length - 1; i >= 0; --i) {
-        const k = path12[i];
+      for (let i = path14.length - 1; i >= 0; --i) {
+        const k = path14[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -32079,7 +32079,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path12) => path12 == null || typeof path12 === "object" && !!path12[Symbol.iterator]().next().done;
+    var isEmptyPath = (path14) => path14 == null || typeof path14 === "object" && !!path14[Symbol.iterator]().next().done;
     var Collection = class extends Node2.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -32109,11 +32109,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path12, value3) {
-        if (isEmptyPath(path12))
+      addIn(path14, value3) {
+        if (isEmptyPath(path14))
           this.add(value3);
         else {
-          const [key, ...rest] = path12;
+          const [key, ...rest] = path14;
           const node = this.get(key, true);
           if (identity2.isCollection(node))
             node.addIn(rest, value3);
@@ -32127,8 +32127,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        const [key, ...rest] = path12;
+      deleteIn(path14) {
+        const [key, ...rest] = path14;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -32142,8 +32142,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        const [key, ...rest] = path12;
+      getIn(path14, keepScalar) {
+        const [key, ...rest] = path14;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity2.isScalar(node) ? node.value : node;
@@ -32161,8 +32161,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path12) {
-        const [key, ...rest] = path12;
+      hasIn(path14) {
+        const [key, ...rest] = path14;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -32172,8 +32172,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value3) {
-        const [key, ...rest] = path12;
+      setIn(path14, value3) {
+        const [key, ...rest] = path14;
         if (rest.length === 0) {
           this.set(key, value3);
         } else {
@@ -34688,9 +34688,9 @@ var require_Document = __commonJS({
           this.contents.add(value3);
       }
       /** Adds a value to the document. */
-      addIn(path12, value3) {
+      addIn(path14, value3) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path12, value3);
+          this.contents.addIn(path14, value3);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -34765,14 +34765,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path12) {
-        if (Collection.isEmptyPath(path12)) {
+      deleteIn(path14) {
+        if (Collection.isEmptyPath(path14)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path12) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path14) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -34787,10 +34787,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path12, keepScalar) {
-        if (Collection.isEmptyPath(path12))
+      getIn(path14, keepScalar) {
+        if (Collection.isEmptyPath(path14))
           return !keepScalar && identity2.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity2.isCollection(this.contents) ? this.contents.getIn(path12, keepScalar) : void 0;
+        return identity2.isCollection(this.contents) ? this.contents.getIn(path14, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -34801,10 +34801,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path12) {
-        if (Collection.isEmptyPath(path12))
+      hasIn(path14) {
+        if (Collection.isEmptyPath(path14))
           return this.contents !== void 0;
-        return identity2.isCollection(this.contents) ? this.contents.hasIn(path12) : false;
+        return identity2.isCollection(this.contents) ? this.contents.hasIn(path14) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -34821,13 +34821,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path12, value3) {
-        if (Collection.isEmptyPath(path12)) {
+      setIn(path14, value3) {
+        if (Collection.isEmptyPath(path14)) {
           this.contents = value3;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path12), value3);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path14), value3);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path12, value3);
+          this.contents.setIn(path14, value3);
         }
       }
       /**
@@ -36787,9 +36787,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path12) => {
+    visit.itemAtPath = (cst, path14) => {
       let item = cst;
-      for (const [field, index2] of path12) {
+      for (const [field, index2] of path14) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index2];
@@ -36798,23 +36798,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path12) => {
-      const parent = visit.itemAtPath(cst, path12.slice(0, -1));
-      const field = path12[path12.length - 1][0];
+    visit.parentCollection = (cst, path14) => {
+      const parent = visit.itemAtPath(cst, path14.slice(0, -1));
+      const field = path14[path14.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path12, item, visitor) {
-      let ctrl = visitor(item, path12);
+    function _visit(path14, item, visitor) {
+      let ctrl = visitor(item, path14);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path12.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path14.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -36825,10 +36825,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path12);
+            ctrl = ctrl(item, path14);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path12) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path14) : ctrl;
     }
     exports.visit = visit;
   }
@@ -38581,7 +38581,7 @@ var require_dist = __commonJS({
 
 // dist/cli.js
 import * as fs3 from "node:fs";
-import * as path11 from "node:path";
+import * as path13 from "node:path";
 
 // node_modules/.pnpm/effect@4.0.0-beta.100/node_modules/effect/dist/Pipeable.js
 var pipeArguments = (self, args2) => {
@@ -39154,8 +39154,8 @@ var CIRCULAR = "[Circular]";
 function formatPropertyKey(name) {
   return typeof name === "string" ? JSON.stringify(name) : String(name);
 }
-function formatPath(path12) {
-  return path12.map((key) => `[${formatPropertyKey(key)}]`).join("");
+function formatPath(path14) {
+  return path14.map((key) => `[${formatPropertyKey(key)}]`).join("");
 }
 function formatDate(date7) {
   try {
@@ -45784,9 +45784,9 @@ var Pointer = class extends Base {
    * The issue that occurred.
    */
   issue;
-  constructor(path12, issue) {
+  constructor(path14, issue) {
     super();
-    this.path = path12;
+    this.path = path14;
     this.issue = issue;
   }
 };
@@ -45992,50 +45992,50 @@ function makeFormatterStandardSchemaV1(options) {
 function getExpectedMessage(expected, actual) {
   return `Expected ${expected}, got ${actual}`;
 }
-function toDefaultIssues(issue, path12, leafHook, checkHook) {
+function toDefaultIssues(issue, path14, leafHook, checkHook) {
   switch (issue._tag) {
     case "Filter": {
       const message = checkHook(issue);
       if (message !== void 0) {
         return [{
-          path: path12,
+          path: path14,
           message
         }];
       }
       switch (issue.issue._tag) {
         case "InvalidValue":
           return [{
-            path: path12,
+            path: path14,
             message: getExpectedMessage(formatCheck(issue.filter), format(issue.actual))
           }];
         default:
-          return toDefaultIssues(issue.issue, path12, leafHook, checkHook);
+          return toDefaultIssues(issue.issue, path14, leafHook, checkHook);
       }
     }
     case "Encoding":
-      return toDefaultIssues(issue.issue, path12, leafHook, checkHook);
+      return toDefaultIssues(issue.issue, path14, leafHook, checkHook);
     case "Pointer":
-      return toDefaultIssues(issue.issue, [...path12, ...issue.path], leafHook, checkHook);
+      return toDefaultIssues(issue.issue, [...path14, ...issue.path], leafHook, checkHook);
     case "Composite":
-      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path12, leafHook, checkHook));
+      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path14, leafHook, checkHook));
     case "AnyOf": {
       const message = findMessage(issue);
       if (issue.issues.length === 0) {
         if (message !== void 0) return [{
-          path: path12,
+          path: path14,
           message
         }];
         const expected = getExpectedMessage(getExpected(issue.ast), format(issue.actual));
         return [{
-          path: path12,
+          path: path14,
           message: expected
         }];
       }
-      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path12, leafHook, checkHook));
+      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path14, leafHook, checkHook));
     }
     default:
       return [{
-        path: path12,
+        path: path14,
         message: leafHook(issue)
       }];
   }
@@ -46057,9 +46057,9 @@ var defaultFormatter = /* @__PURE__ */ makeFormatterDefault();
 function formatDefaultIssue(issue) {
   let out = issue.message;
   if (issue.path && issue.path.length > 0) {
-    const path12 = formatPath(issue.path);
+    const path14 = formatPath(issue.path);
     out += `
-  at ${path12}`;
+  at ${path14}`;
   }
   return out;
 }
@@ -50037,8 +50037,8 @@ var FileSystem = /* @__PURE__ */ Service("effect/platform/FileSystem");
 var make19 = (impl) => FileSystem.of({
   ...impl,
   [TypeId28]: TypeId28,
-  exists: (path12) => pipe(impl.access(path12), as3(true), catchTag3("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed6(false) : fail6(e))),
-  readFileString: (path12, encoding) => flatMap5(impl.readFile(path12), (_) => try_3({
+  exists: (path14) => pipe(impl.access(path14), as3(true), catchTag3("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed6(false) : fail6(e))),
+  readFileString: (path14, encoding) => flatMap5(impl.readFile(path14), (_) => try_3({
     try: () => new TextDecoder(encoding).decode(_),
     catch: (cause) => badArgument({
       module: "FileSystem",
@@ -50047,8 +50047,8 @@ var make19 = (impl) => FileSystem.of({
       cause
     })
   })),
-  stream: fnUntraced2(function* (path12, options) {
-    const file4 = yield* impl.open(path12, {
+  stream: fnUntraced2(function* (path14, options) {
+    const file4 = yield* impl.open(path14, {
       flag: "r"
     });
     if (options?.offset) {
@@ -50071,11 +50071,11 @@ var make19 = (impl) => FileSystem.of({
       }
     }))));
   }, unwrap4),
-  sink: (path12, options) => pipe(impl.open(path12, {
+  sink: (path14, options) => pipe(impl.open(path14, {
     flag: "w",
     ...options
   }), map7((file4) => forEach3((_) => file4.writeAll(_))), unwrap3),
-  writeFileString: (path12, data, options) => flatMap5(try_3({
+  writeFileString: (path14, data, options) => flatMap5(try_3({
     try: () => new TextEncoder().encode(data),
     catch: (cause) => badArgument({
       module: "FileSystem",
@@ -50083,31 +50083,31 @@ var make19 = (impl) => FileSystem.of({
       description: "could not encode string",
       cause
     })
-  }), (_) => impl.writeFile(path12, _, options))
+  }), (_) => impl.writeFile(path14, _, options))
 });
-var notFound = (method, path12) => systemError({
+var notFound = (method, path14) => systemError({
   module: "FileSystem",
   method,
   _tag: "NotFound",
   description: "No such file or directory",
-  pathOrDescriptor: path12
+  pathOrDescriptor: path14
 });
 var makeNoop = (fileSystem) => FileSystem.of({
   [TypeId28]: TypeId28,
-  access(path12) {
-    return fail6(notFound("access", path12));
+  access(path14) {
+    return fail6(notFound("access", path14));
   },
-  chmod(path12) {
-    return fail6(notFound("chmod", path12));
+  chmod(path14) {
+    return fail6(notFound("chmod", path14));
   },
-  chown(path12) {
-    return fail6(notFound("chown", path12));
+  chown(path14) {
+    return fail6(notFound("chown", path14));
   },
-  copy(path12) {
-    return fail6(notFound("copy", path12));
+  copy(path14) {
+    return fail6(notFound("copy", path14));
   },
-  copyFile(path12) {
-    return fail6(notFound("copyFile", path12));
+  copyFile(path14) {
+    return fail6(notFound("copyFile", path14));
   },
   glob(pattern) {
     return fail6(notFound("glob", pattern));
@@ -50115,8 +50115,8 @@ var makeNoop = (fileSystem) => FileSystem.of({
   exists() {
     return succeed6(false);
   },
-  link(path12) {
-    return fail6(notFound("link", path12));
+  link(path14) {
+    return fail6(notFound("link", path14));
   },
   makeDirectory() {
     return die2("not implemented");
@@ -50133,23 +50133,23 @@ var makeNoop = (fileSystem) => FileSystem.of({
   makeTempFileScoped() {
     return die2("not implemented");
   },
-  open(path12) {
-    return fail6(notFound("open", path12));
+  open(path14) {
+    return fail6(notFound("open", path14));
   },
-  readDirectory(path12) {
-    return fail6(notFound("readDirectory", path12));
+  readDirectory(path14) {
+    return fail6(notFound("readDirectory", path14));
   },
-  readFile(path12) {
-    return fail6(notFound("readFile", path12));
+  readFile(path14) {
+    return fail6(notFound("readFile", path14));
   },
-  readFileString(path12) {
-    return fail6(notFound("readFileString", path12));
+  readFileString(path14) {
+    return fail6(notFound("readFileString", path14));
   },
-  readLink(path12) {
-    return fail6(notFound("readLink", path12));
+  readLink(path14) {
+    return fail6(notFound("readLink", path14));
   },
-  realPath(path12) {
-    return fail6(notFound("realPath", path12));
+  realPath(path14) {
+    return fail6(notFound("realPath", path14));
   },
   remove() {
     return void_5;
@@ -50157,32 +50157,32 @@ var makeNoop = (fileSystem) => FileSystem.of({
   rename(oldPath) {
     return fail6(notFound("rename", oldPath));
   },
-  sink(path12) {
-    return fail9(notFound("sink", path12));
+  sink(path14) {
+    return fail9(notFound("sink", path14));
   },
-  stat(path12) {
-    return fail6(notFound("stat", path12));
+  stat(path14) {
+    return fail6(notFound("stat", path14));
   },
-  stream(path12) {
-    return fail10(notFound("stream", path12));
+  stream(path14) {
+    return fail10(notFound("stream", path14));
   },
   symlink(fromPath) {
     return fail6(notFound("symlink", fromPath));
   },
-  truncate(path12) {
-    return fail6(notFound("truncate", path12));
+  truncate(path14) {
+    return fail6(notFound("truncate", path14));
   },
-  utimes(path12) {
-    return fail6(notFound("utimes", path12));
+  utimes(path14) {
+    return fail6(notFound("utimes", path14));
   },
-  watch(path12) {
-    return fail10(notFound("watch", path12));
+  watch(path14) {
+    return fail10(notFound("watch", path14));
   },
-  writeFile(path12) {
-    return fail6(notFound("writeFile", path12));
+  writeFile(path14) {
+    return fail6(notFound("writeFile", path14));
   },
-  writeFileString(path12) {
-    return fail6(notFound("writeFileString", path12));
+  writeFileString(path14) {
+    return fail6(notFound("writeFileString", path14));
   },
   ...fileSystem
 });
@@ -50202,15 +50202,15 @@ __export(Path_exports, {
 });
 var TypeId29 = "~effect/platform/Path";
 var Path = /* @__PURE__ */ Service("effect/Path");
-function normalizeStringPosix(path12, allowAboveRoot) {
+function normalizeStringPosix(path14, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let code;
-  for (let i = 0; i <= path12.length; ++i) {
-    if (i < path12.length) {
-      code = path12.charCodeAt(i);
+  for (let i = 0; i <= path14.length; ++i) {
+    if (i < path14.length) {
+      code = path14.charCodeAt(i);
     } else if (code === 47) {
       break;
     } else {
@@ -50252,9 +50252,9 @@ function normalizeStringPosix(path12, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += "/" + path12.slice(lastSlash + 1, i);
+          res += "/" + path14.slice(lastSlash + 1, i);
         } else {
-          res = path12.slice(lastSlash + 1, i);
+          res = path14.slice(lastSlash + 1, i);
         }
         lastSegmentLength = i - lastSlash - 1;
       }
@@ -50313,21 +50313,21 @@ var resolve2 = function resolve3() {
   let resolvedAbsolute = false;
   let cwd = void 0;
   for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    let path12;
+    let path14;
     if (i >= 0) {
-      path12 = arguments[i];
+      path14 = arguments[i];
     } else {
       const process2 = globalThis.process;
       if (cwd === void 0 && "process" in globalThis && typeof process2 === "object" && process2 !== null && typeof process2.cwd === "function") {
         cwd = process2.cwd();
       }
-      path12 = cwd;
+      path14 = cwd;
     }
-    if (path12.length === 0) {
+    if (path14.length === 0) {
       continue;
     }
-    resolvedPath = path12 + "/" + resolvedPath;
-    resolvedAbsolute = path12.charCodeAt(0) === 47;
+    resolvedPath = path14 + "/" + resolvedPath;
+    resolvedAbsolute = path14.charCodeAt(0) === 47;
   }
   resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
   if (resolvedAbsolute) {
@@ -50379,18 +50379,18 @@ function encodePathChars(filepath) {
 var posixImpl = /* @__PURE__ */ Path.of({
   [TypeId29]: TypeId29,
   resolve: resolve2,
-  normalize(path12) {
-    if (path12.length === 0) return ".";
-    const isAbsolute2 = path12.charCodeAt(0) === 47;
-    const trailingSeparator = path12.charCodeAt(path12.length - 1) === 47;
-    path12 = normalizeStringPosix(path12, !isAbsolute2);
-    if (path12.length === 0 && !isAbsolute2) path12 = ".";
-    if (path12.length > 0 && trailingSeparator) path12 += "/";
-    if (isAbsolute2) return "/" + path12;
-    return path12;
+  normalize(path14) {
+    if (path14.length === 0) return ".";
+    const isAbsolute2 = path14.charCodeAt(0) === 47;
+    const trailingSeparator = path14.charCodeAt(path14.length - 1) === 47;
+    path14 = normalizeStringPosix(path14, !isAbsolute2);
+    if (path14.length === 0 && !isAbsolute2) path14 = ".";
+    if (path14.length > 0 && trailingSeparator) path14 += "/";
+    if (isAbsolute2) return "/" + path14;
+    return path14;
   },
-  isAbsolute(path12) {
-    return path12.length > 0 && path12.charCodeAt(0) === 47;
+  isAbsolute(path14) {
+    return path14.length > 0 && path14.charCodeAt(0) === 47;
   },
   join() {
     if (arguments.length === 0) {
@@ -50481,14 +50481,14 @@ var posixImpl = /* @__PURE__ */ Path.of({
       return to.slice(toStart);
     }
   },
-  dirname(path12) {
-    if (path12.length === 0) return ".";
-    let code = path12.charCodeAt(0);
+  dirname(path14) {
+    if (path14.length === 0) return ".";
+    let code = path14.charCodeAt(0);
     const hasRoot = code === 47;
     let end = -1;
     let matchedSlash = true;
-    for (let i = path12.length - 1; i >= 1; --i) {
-      code = path12.charCodeAt(i);
+    for (let i = path14.length - 1; i >= 1; --i) {
+      code = path14.charCodeAt(i);
       if (code === 47) {
         if (!matchedSlash) {
           end = i;
@@ -50500,19 +50500,19 @@ var posixImpl = /* @__PURE__ */ Path.of({
     }
     if (end === -1) return hasRoot ? "/" : ".";
     if (hasRoot && end === 1) return "//";
-    return path12.slice(0, end);
+    return path14.slice(0, end);
   },
-  basename(path12, ext) {
+  basename(path14, ext) {
     let start = 0;
     let end = -1;
     let matchedSlash = true;
     let i;
-    if (ext !== void 0 && ext.length > 0 && ext.length <= path12.length) {
-      if (ext.length === path12.length && ext === path12) return "";
+    if (ext !== void 0 && ext.length > 0 && ext.length <= path14.length) {
+      if (ext.length === path14.length && ext === path14) return "";
       let extIdx = ext.length - 1;
       let firstNonSlashEnd = -1;
-      for (i = path12.length - 1; i >= 0; --i) {
-        const code = path12.charCodeAt(i);
+      for (i = path14.length - 1; i >= 0; --i) {
+        const code = path14.charCodeAt(i);
         if (code === 47) {
           if (!matchedSlash) {
             start = i + 1;
@@ -50536,11 +50536,11 @@ var posixImpl = /* @__PURE__ */ Path.of({
         }
       }
       if (start === end) end = firstNonSlashEnd;
-      else if (end === -1) end = path12.length;
-      return path12.slice(start, end);
+      else if (end === -1) end = path14.length;
+      return path14.slice(start, end);
     } else {
-      for (i = path12.length - 1; i >= 0; --i) {
-        if (path12.charCodeAt(i) === 47) {
+      for (i = path14.length - 1; i >= 0; --i) {
+        if (path14.charCodeAt(i) === 47) {
           if (!matchedSlash) {
             start = i + 1;
             break;
@@ -50551,17 +50551,17 @@ var posixImpl = /* @__PURE__ */ Path.of({
         }
       }
       if (end === -1) return "";
-      return path12.slice(start, end);
+      return path14.slice(start, end);
     }
   },
-  extname(path12) {
+  extname(path14) {
     let startDot = -1;
     let startPart = 0;
     let end = -1;
     let matchedSlash = true;
     let preDotState = 0;
-    for (let i = path12.length - 1; i >= 0; --i) {
-      const code = path12.charCodeAt(i);
+    for (let i = path14.length - 1; i >= 0; --i) {
+      const code = path14.charCodeAt(i);
       if (code === 47) {
         if (!matchedSlash) {
           startPart = i + 1;
@@ -50588,7 +50588,7 @@ var posixImpl = /* @__PURE__ */ Path.of({
     preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
       return "";
     }
-    return path12.slice(startDot, end);
+    return path14.slice(startDot, end);
   },
   format: function format4(pathObject) {
     if (pathObject === null || typeof pathObject !== "object") {
@@ -50596,7 +50596,7 @@ var posixImpl = /* @__PURE__ */ Path.of({
     }
     return _format("/", pathObject);
   },
-  parse(path12) {
+  parse(path14) {
     const ret = {
       root: "",
       dir: "",
@@ -50604,8 +50604,8 @@ var posixImpl = /* @__PURE__ */ Path.of({
       ext: "",
       name: ""
     };
-    if (path12.length === 0) return ret;
-    let code = path12.charCodeAt(0);
+    if (path14.length === 0) return ret;
+    let code = path14.charCodeAt(0);
     const isAbsolute2 = code === 47;
     let start;
     if (isAbsolute2) {
@@ -50618,10 +50618,10 @@ var posixImpl = /* @__PURE__ */ Path.of({
     let startPart = 0;
     let end = -1;
     let matchedSlash = true;
-    let i = path12.length - 1;
+    let i = path14.length - 1;
     let preDotState = 0;
     for (; i >= start; --i) {
-      code = path12.charCodeAt(i);
+      code = path14.charCodeAt(i);
       if (code === 47) {
         if (!matchedSlash) {
           startPart = i + 1;
@@ -50644,20 +50644,20 @@ var posixImpl = /* @__PURE__ */ Path.of({
     preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
     preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
       if (end !== -1) {
-        if (startPart === 0 && isAbsolute2) ret.base = ret.name = path12.slice(1, end);
-        else ret.base = ret.name = path12.slice(startPart, end);
+        if (startPart === 0 && isAbsolute2) ret.base = ret.name = path14.slice(1, end);
+        else ret.base = ret.name = path14.slice(startPart, end);
       }
     } else {
       if (startPart === 0 && isAbsolute2) {
-        ret.name = path12.slice(1, startDot);
-        ret.base = path12.slice(1, end);
+        ret.name = path14.slice(1, startDot);
+        ret.base = path14.slice(1, end);
       } else {
-        ret.name = path12.slice(startPart, startDot);
-        ret.base = path12.slice(startPart, end);
+        ret.name = path14.slice(startPart, startDot);
+        ret.base = path14.slice(startPart, end);
       }
-      ret.ext = path12.slice(startDot, end);
+      ret.ext = path14.slice(startDot, end);
     }
-    if (startPart > 0) ret.dir = path12.slice(0, startPart - 1);
+    if (startPart > 0) ret.dir = path14.slice(0, startPart - 1);
     else if (isAbsolute2) ret.dir = "/";
     return ret;
   },
@@ -50827,7 +50827,7 @@ import * as NodeChildProcess from "node:child_process";
 import { PassThrough } from "node:stream";
 
 // node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.100_effect@4.0.0-beta.100/node_modules/@effect/platform-node-shared/dist/internal/utils.js
-var handleErrnoException = (module, method) => (err, [path12]) => {
+var handleErrnoException = (module, method) => (err, [path14]) => {
   let reason = "Unknown";
   switch (err.code) {
     case "ENOENT":
@@ -50856,7 +50856,7 @@ var handleErrnoException = (module, method) => (err, [path12]) => {
     _tag: reason,
     module,
     method,
-    pathOrDescriptor: path12,
+    pathOrDescriptor: path14,
     syscall: err.syscall,
     cause: err
   });
@@ -50975,11 +50975,11 @@ var toPlatformError = (method, error2, command) => {
 };
 var make23 = /* @__PURE__ */ gen4(function* () {
   const fs4 = yield* FileSystem;
-  const path12 = yield* Path;
+  const path14 = yield* Path;
   const resolveWorkingDirectory = fnUntraced2(function* (options) {
     if (isUndefined(options.cwd)) return void 0;
     yield* fs4.access(options.cwd);
-    return path12.resolve(options.cwd);
+    return path14.resolve(options.cwd);
   });
   const resolveEnvironment = (options) => {
     return options.extendEnv ? {
@@ -52484,10 +52484,10 @@ function makeReducer2(combiner2) {
 }
 
 // node_modules/.pnpm/effect@4.0.0-beta.100/node_modules/effect/dist/internal/errors.js
-function errorWithPath(message, path12) {
-  if (path12.length > 0) {
+function errorWithPath(message, path14) {
+  if (path14.length > 0) {
     message += `
-  at ${formatPath(path12)}`;
+  at ${formatPath(path14)}`;
   }
   return new Error(message);
 }
@@ -52779,7 +52779,7 @@ function finiteNumberContext(ctx) {
     constraint: finiteNumberConstraint
   };
 }
-function reportChecks(report, checks, path12) {
+function reportChecks(report, checks, path14) {
   function visit(check3, covered) {
     const arbitrary = check3.annotations?.arbitrary;
     const nextCovered = covered || arbitrary?.constraint !== void 0 || arbitrary?.candidate !== void 0;
@@ -52792,7 +52792,7 @@ function reportChecks(report, checks, path12) {
       const description = typeof meta === "object" && meta !== null && "_tag" in meta && typeof meta._tag === "string" ? meta._tag : check3.annotations?.identifier ?? check3.annotations?.expected;
       report.warnings.push({
         _tag: "OpaqueFilter",
-        path: path12,
+        path: path14,
         ...description === void 0 ? {} : {
           description
         }
@@ -52803,37 +52803,37 @@ function reportChecks(report, checks, path12) {
 }
 function collectReport(ast, report) {
   const stack = /* @__PURE__ */ new WeakSet();
-  function visit(ast2, path12) {
+  function visit(ast2, path14) {
     if (stack.has(ast2)) {
       return;
     }
     stack.add(ast2);
-    reportChecks(report, ast2.checks, path12);
+    reportChecks(report, ast2.checks, path14);
     switch (ast2._tag) {
       case "Declaration":
-        ast2.typeParameters.forEach((tp) => visit(tp, path12));
+        ast2.typeParameters.forEach((tp) => visit(tp, path14));
         break;
       case "Arrays": {
         for (const [i, type] of [...ast2.elements, ...ast2.rest].entries()) {
-          visit(type, [...path12, i]);
+          visit(type, [...path14, i]);
         }
         break;
       }
       case "Objects":
-        ast2.propertySignatures.forEach((ps) => visit(ps.type, [...path12, ps.name]));
+        ast2.propertySignatures.forEach((ps) => visit(ps.type, [...path14, ps.name]));
         ast2.indexSignatures.forEach((is3) => {
-          visit(is3.parameter, path12);
-          visit(is3.type, path12);
+          visit(is3.parameter, path14);
+          visit(is3.type, path14);
         });
         break;
       case "Union":
-        ast2.types.forEach((type) => visit(type, path12));
+        ast2.types.forEach((type) => visit(type, path14));
         break;
       case "TemplateLiteral":
-        ast2.parts.forEach((part, i) => visit(toEncoded(part), [...path12, i]));
+        ast2.parts.forEach((part, i) => visit(toEncoded(part), [...path14, i]));
         break;
       case "Suspend":
-        visit(ast2.thunk(), path12);
+        visit(ast2.thunk(), path14);
         break;
     }
     stack.delete(ast2);
@@ -52900,26 +52900,26 @@ function filterLayer(ast, checks, normalBase, terminalBase) {
   });
 }
 var memoized = /* @__PURE__ */ memoize((ast) => recur(ast, []));
-function recur(ast, path12) {
+function recur(ast, path14) {
   const annotation = resolve(ast)?.toArbitrary;
   if (annotation) {
-    const typeParameters = isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path12)) : [];
+    const typeParameters = isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path14)) : [];
     const checks = collectChecks(ast.checks);
     const derive = (lazyNormal) => (fc, ctx, nextCtx, recursionStack) => normalizeDerivation(annotation(makeTypeParameters(typeParameters, fc, resetContext(ctx), recursionStack, lazyNormal))(fc, nextCtx), typeParameters.length > 0)[lazyNormal ? "terminal" : "arbitrary"];
     return filterLayer(ast, checks, derive(false), derive(true));
   }
   if (ast.checks) {
     const checks = collectChecks(ast.checks);
-    const lawc = recur(replaceChecks(ast, void 0), path12);
+    const lawc = recur(replaceChecks(ast, void 0), path14);
     return filterLayer(ast, checks, (fc, _ctx, nextCtx, recursionStack) => lawc(fc, nextCtx, recursionStack), (fc, _ctx, nextCtx, recursionStack) => lawc.terminal(fc, nextCtx, recursionStack));
   }
-  return base(ast, path12);
+  return base(ast, path14);
 }
-function base(ast, path12) {
+function base(ast, path14) {
   switch (ast._tag) {
     case "Never":
     case "Declaration":
-      throw errorWithPath(`Unsupported AST ${ast._tag}`, path12);
+      throw errorWithPath(`Unsupported AST ${ast._tag}`, path14);
     case "Null":
       return same((fc) => fc.constant(null));
     case "Void":
@@ -52956,20 +52956,20 @@ function base(ast, path12) {
     case "ObjectKeyword":
       return same((fc) => fc.oneof(fc.object(), fc.array(fc.anything())));
     case "Enum":
-      return recur(enumsToLiterals(ast), path12);
+      return recur(enumsToLiterals(ast), path14);
     case "TemplateLiteral": {
-      const parts = ast.parts.map((part, i) => recur(toEncoded(part), [...path12, i]));
+      const parts = ast.parts.map((part, i) => recur(toEncoded(part), [...path14, i]));
       return same((fc, ctx, recursionStack) => fc.tuple(...parts.map((part) => part(fc, finiteNumberContext(ctx), recursionStack))).map((segments) => segments.map((segment) => globalThis.String(segment)).join("")));
     }
     case "Arrays": {
       const elements = ast.elements.map((ast2, i) => ({
         ast: ast2,
-        arbitrary: recur(ast2, [...path12, i])
+        arbitrary: recur(ast2, [...path14, i])
       }));
       const len = ast.elements.length;
       const rest = ast.rest.map((ast2, i) => ({
         ast: ast2,
-        arbitrary: recur(ast2, [...path12, len + i])
+        arbitrary: recur(ast2, [...path14, len + i])
       }));
       const terminal = (fc, ctx, recursionStack) => {
         const reset2 = resetContext(ctx);
@@ -53069,12 +53069,12 @@ function base(ast, path12) {
     case "Objects": {
       const propertySignatures = ast.propertySignatures.map((ps) => ({
         ps,
-        arbitrary: recur(ps.type, [...path12, ps.name])
+        arbitrary: recur(ps.type, [...path14, ps.name])
       }));
       const indexSignatures = ast.indexSignatures.map((is3) => ({
         is: is3,
-        parameter: recur(is3.parameter, path12),
-        type: recur(is3.type, path12)
+        parameter: recur(is3.parameter, path14),
+        type: recur(is3.type, path14)
       }));
       const terminal = (fc, ctx, recursionStack) => {
         const reset2 = resetContext(ctx);
@@ -53177,7 +53177,7 @@ function base(ast, path12) {
       }, terminal);
     }
     case "Union": {
-      const types = ast.types.map((ast2) => recur(ast2, path12));
+      const types = ast.types.map((ast2) => recur(ast2, path14));
       const terminal = (fc, ctx, recursionStack) => oneOf(fc, types.map((type) => type.terminal(fc, ctx, recursionStack)).filter(isNotUndefined));
       return makeLazy((fc, ctx, recursionStack) => {
         const arbitraries = types.map((type) => type(fc, ctx, recursionStack));
@@ -53197,7 +53197,7 @@ function base(ast, path12) {
     case "Suspend": {
       const memo2 = arbitraryMemoMap.get(ast);
       if (memo2) return memo2;
-      const get6 = memoizeThunk(() => recur(ast.thunk(), path12));
+      const get6 = memoizeThunk(() => recur(ast.thunk(), path14));
       const out = makeLazy((fc, ctx, recursionStack) => {
         const recursion = getSuspendRecursion(fc, ast);
         const nextCtx = {
@@ -53207,7 +53207,7 @@ function base(ast, path12) {
         const nextStack = recursionStack.includes(ast) ? recursionStack : [...recursionStack, ast];
         const terminal = get6().terminal(fc, nextCtx, nextStack);
         if (terminal === void 0) {
-          throw errorWithPath("Unable to derive an arbitrary for a recursive schema without a finite generation path", path12);
+          throw errorWithPath("Unable to derive an arbitrary for a recursive schema without a finite generation path", path14);
         }
         return fc.oneof(recursion, terminal, fc.constant(null).chain(() => get6()(fc, nextCtx, nextStack)));
       }, (fc, ctx, recursionStack) => {
@@ -53506,14 +53506,14 @@ var recur2 = /* @__PURE__ */ memoize((ast) => {
 var toEquivalence = /* @__PURE__ */ memoize((ast) => {
   return recur3(ast, []);
 });
-function recur3(ast, path12) {
+function recur3(ast, path14) {
   const annotation = resolve(ast)?.["toEquivalence"];
   if (annotation) {
-    return annotation(isDeclaration(ast) ? ast.typeParameters.map((tp) => recur3(tp, path12)) : []);
+    return annotation(isDeclaration(ast) ? ast.typeParameters.map((tp) => recur3(tp, path14)) : []);
   }
   switch (ast._tag) {
     case "Never":
-      throw errorWithPath(`Unsupported AST ${ast._tag}`, path12);
+      throw errorWithPath(`Unsupported AST ${ast._tag}`, path14);
     case "Declaration":
     case "Null":
     case "Undefined":
@@ -53532,9 +53532,9 @@ function recur3(ast, path12) {
     case "TemplateLiteral":
       return equals;
     case "Arrays": {
-      const elements = ast.elements.map((e, i) => recur3(e, [...path12, i]));
+      const elements = ast.elements.map((e, i) => recur3(e, [...path14, i]));
       const len = ast.elements.length;
-      const rest = ast.rest.map((r, i) => recur3(r, [...path12, len + i]));
+      const rest = ast.rest.map((r, i) => recur3(r, [...path14, len + i]));
       return make2((a, b) => {
         if (!Array.isArray(a) || !Array.isArray(b)) {
           return false;
@@ -53569,8 +53569,8 @@ function recur3(ast, path12) {
       if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
         return equals;
       }
-      const propertySignatures = ast.propertySignatures.map((ps) => recur3(ps.type, [...path12, ps.name]));
-      const indexSignatures = ast.indexSignatures.map((is3) => recur3(is3.type, path12));
+      const propertySignatures = ast.propertySignatures.map((ps) => recur3(ps.type, [...path14, ps.name]));
+      const indexSignatures = ast.indexSignatures.map((is3) => recur3(is3.type, path14));
       return make2((a, b) => {
         if (!isObject(a) || !isObject(b)) {
           return false;
@@ -53611,13 +53611,13 @@ function recur3(ast, path12) {
         for (let i = 0; i < candidates.length; i++) {
           const is3 = types[i];
           if (is3(a) && is3(b)) {
-            return recur3(candidates[i], path12)(a, b);
+            return recur3(candidates[i], path14)(a, b);
           }
         }
         return false;
       });
     case "Suspend": {
-      const get6 = memoizeThunk(() => recur3(ast.thunk(), path12));
+      const get6 = memoizeThunk(() => recur3(ast.thunk(), path14));
       return make2((a, b) => get6()(a, b));
     }
   }
@@ -54559,10 +54559,10 @@ function get5(oldValue, newValue) {
     const len2 = newValue.length;
     const shared = Math.min(len1, len2);
     for (let i = 0; i < shared; i++) {
-      const path12 = `/${i}`;
+      const path14 = `/${i}`;
       const patch = get5(oldValue[i], newValue[i]);
       for (const op of patch) {
-        prefixPathInPlace(op, path12);
+        prefixPathInPlace(op, path14);
         patches.push(op);
       }
     }
@@ -54587,25 +54587,25 @@ function get5(oldValue, newValue) {
     const allKeys = Array.from(/* @__PURE__ */ new Set([...keys1, ...keys22])).sort();
     for (const key of allKeys) {
       const esc = escapeToken(key);
-      const path12 = `/${esc}`;
+      const path14 = `/${esc}`;
       const hasKey1 = Object.hasOwn(oldValue, key);
       const hasKey2 = Object.hasOwn(newValue, key);
       if (hasKey1 && hasKey2) {
         const patch = get5(oldValue[key], newValue[key]);
         for (const op of patch) {
-          prefixPathInPlace(op, path12);
+          prefixPathInPlace(op, path14);
           patches.push(op);
         }
       } else if (!hasKey1 && hasKey2) {
         patches.push({
           op: "add",
-          path: path12,
+          path: path14,
           value: newValue[key]
         });
       } else if (hasKey1 && !hasKey2) {
         patches.push({
           op: "remove",
-          path: path12
+          path: path14
         });
       }
     }
@@ -54951,8 +54951,8 @@ var OptionalNode = class {
 var PathNode = class {
   _tag = "PathNode";
   path;
-  constructor(path12) {
-    this.path = path12;
+  constructor(path14) {
+    this.path = path14;
   }
 };
 var CheckNode = class {
@@ -55198,24 +55198,24 @@ var recur4 = /* @__PURE__ */ memoize((node) => {
       return {
         _tag: "LensNode",
         get: (s) => {
-          const path12 = node.path;
+          const path14 = node.path;
           let out = s;
-          for (let i = 0, n = path12.length; i < n; i++) {
-            out = out[path12[i]];
+          for (let i = 0, n = path14.length; i < n; i++) {
+            out = out[path14[i]];
           }
           return out;
         },
         set: (a, s) => {
-          const path12 = node.path;
+          const path14 = node.path;
           const out = cloneShallow(s);
           let current = out;
           let i = 0;
-          for (; i < path12.length - 1; i++) {
-            const key = path12[i];
+          for (; i < path14.length - 1; i++) {
+            const key = path14[i];
             current[key] = cloneShallow(current[key]);
             current = current[key];
           }
-          const finalKey = path12[i];
+          const finalKey = path14[i];
           current[finalKey] = a;
           return out;
         }
@@ -57542,10 +57542,10 @@ var RunExecution = class RunExecution2 {
     }
     return failures;
   }
-  static mergePaths(offsetPath, path12) {
-    if (offsetPath.length === 0) return path12;
+  static mergePaths(offsetPath, path14) {
+    if (offsetPath.length === 0) return path14;
     const offsetItems = offsetPath.split(":");
-    const remainingItems = path12.split(":");
+    const remainingItems = path14.split(":");
     const middle = +offsetItems[offsetItems.length - 1] + +remainingItems[0];
     return [
       ...offsetItems.slice(0, offsetItems.length - 1),
@@ -57732,15 +57732,15 @@ function* lazyToss(generator, seed, random2, examples) {
 function produce(producer) {
   return producer();
 }
-function pathWalk(path12, initialProducers, shrink) {
+function pathWalk(path14, initialProducers, shrink) {
   const producers = initialProducers;
-  const segments = path12.split(":").map((text2) => +text2);
+  const segments = path14.split(":").map((text2) => +text2);
   if (segments.length === 0) return producers.map(produce);
-  if (!segments.every((v) => !Number.isNaN(v))) throw new Error(`Unable to replay, got invalid path=${path12}`);
+  if (!segments.every((v) => !Number.isNaN(v))) throw new Error(`Unable to replay, got invalid path=${path14}`);
   let values2 = producers.drop(segments[0]).map(produce);
   for (const s of segments.slice(1)) {
     const valueToShrink = values2.getNthOrLast(0);
-    if (valueToShrink === null) throw new Error(`Unable to replay, got wrong path=${path12}`);
+    if (valueToShrink === null) throw new Error(`Unable to replay, got wrong path=${path14}`);
     values2 = shrink(valueToShrink).drop(s);
   }
   return values2;
@@ -63046,9 +63046,9 @@ function webSegment(constraints = {}) {
   });
 }
 function segmentsToPathMapper(segments) {
-  let path12 = "";
-  for (let index2 = 0; index2 !== segments.length; ++index2) path12 += "/" + segments[index2];
-  return path12;
+  let path14 = "";
+  for (let index2 = 0; index2 !== segments.length; ++index2) path14 += "/" + segments[index2];
+  return path14;
 }
 function segmentsToPathUnmapper(value3) {
   if (typeof value3 !== "string") throw new Error("Incompatible value received: type");
@@ -63084,8 +63084,8 @@ function webQueryParameters(constraints = {}) {
   return buildUriQueryOrFragmentArbitrary(constraints.size);
 }
 function partsToUrlMapper(data) {
-  const [scheme, authority, path12] = data;
-  return `${scheme}://${authority}${path12}${data[3] === null ? "" : `?${data[3]}`}${data[4] === null ? "" : `#${data[4]}`}`;
+  const [scheme, authority, path14] = data;
+  return `${scheme}://${authority}${path14}${data[3] === null ? "" : `?${data[3]}`}${data[4] === null ? "" : `#${data[4]}`}`;
 }
 var UrlSplitRegex = /^([[A-Za-z][A-Za-z0-9+.-]*):\/\/([^/?#]*)([^?#]*)(\?[A-Za-z0-9\-._~!$&'()*+,;=:@/?%]*)?(#[A-Za-z0-9\-._~!$&'()*+,;=:@/?%]*)?$/;
 function partsToUrlUnmapper(value3) {
@@ -63094,13 +63094,13 @@ function partsToUrlUnmapper(value3) {
   if (m === null) throw new Error("Incompatible value received");
   const scheme = m[1];
   const authority = m[2];
-  const path12 = m[3];
+  const path14 = m[3];
   const query = m[4];
   const fragments = m[5];
   return [
     scheme,
     authority,
-    path12,
+    path14,
     query !== void 0 ? query.substring(1) : null,
     fragments !== void 0 ? fragments.substring(1) : null
   ];
@@ -64816,9 +64816,9 @@ function pushTokens(tokens, regexSource, unicodeMode, groups) {
     tokens.push(currentDisjunction);
   }
 }
-function tokenizeRegex(regex) {
-  const unicodeMode = safeIndexOf([...regex.flags], "u") !== -1;
-  const regexSource = regex.source;
+function tokenizeRegex(regex2) {
+  const unicodeMode = safeIndexOf([...regex2.flags], "u") !== -1;
+  const regexSource = regex2.source;
   const tokens = [];
   pushTokens(tokens, regexSource, unicodeMode, {
     lastIndex: 0,
@@ -64831,9 +64831,9 @@ function getPropertySpec(astNode) {
   if (astNode.binary || astNode.shorthand) return astNode.canonicalValue;
   return `${astNode.canonicalName}=${astNode.canonicalValue}`;
 }
-function appendRangesForRegex(regex, from, to, ranges) {
+function appendRangesForRegex(regex2, from, to, ranges) {
   let currentRangeStart = -1;
-  for (let cp2 = from; cp2 <= to; ++cp2) if (regex.test(safeStringFromCodePoint$1(cp2))) {
+  for (let cp2 = from; cp2 <= to; ++cp2) if (regex2.test(safeStringFromCodePoint$1(cp2))) {
     if (currentRangeStart === -1) currentRangeStart = cp2;
   } else if (currentRangeStart !== -1) {
     const rangeEnd = cp2 - 1;
@@ -64843,10 +64843,10 @@ function appendRangesForRegex(regex, from, to, ranges) {
   if (currentRangeStart !== -1) ranges.push(currentRangeStart === to ? [to] : [currentRangeStart, to]);
 }
 function extractRangesForProperty(propertySpec, negative) {
-  const regex = new RegExp(`^\\${negative ? "P" : "p"}{${propertySpec}}$`, "u");
+  const regex2 = new RegExp(`^\\${negative ? "P" : "p"}{${propertySpec}}$`, "u");
   const ranges = [];
-  appendRangesForRegex(regex, 0, 55295, ranges);
-  appendRangesForRegex(regex, 57344, 1114111, ranges);
+  appendRangesForRegex(regex2, 0, 55295, ranges);
+  appendRangesForRegex(regex2, 57344, 1114111, ranges);
   return ranges;
 }
 var cache = /* @__PURE__ */ new Map();
@@ -65011,18 +65011,18 @@ function toMatchingArbitrary(astNode, constraints, flags) {
       throw raiseUnsupportedASTNode(astNode);
   }
 }
-function stringMatching(regex, constraints = {}) {
-  for (const flag of regex.flags) if (flag !== "d" && flag !== "g" && flag !== "m" && flag !== "s" && flag !== "u") throw new SError(`Unable to use "stringMatching" against a regex using the flag ${flag}`);
+function stringMatching(regex2, constraints = {}) {
+  for (const flag of regex2.flags) if (flag !== "d" && flag !== "g" && flag !== "m" && flag !== "s" && flag !== "u") throw new SError(`Unable to use "stringMatching" against a regex using the flag ${flag}`);
   const maxLength = constraints.maxLength;
   const sanitizedConstraints = {
     size: constraints.size,
     maxLength
   };
   const flags = {
-    multiline: regex.multiline,
-    dotAll: regex.dotAll
+    multiline: regex2.multiline,
+    dotAll: regex2.dotAll
   };
-  let regexRootToken = addMissingDotStar(tokenizeRegex(regex));
+  let regexRootToken = addMissingDotStar(tokenizeRegex(regex2));
   if (maxLength !== void 0) regexRootToken = clampRegexAst(regexRootToken, maxLength);
   const baseArbitrary = toMatchingArbitrary(regexRootToken, sanitizedConstraints, flags);
   if (maxLength !== void 0) return baseArbitrary.filter((s) => [...s].length <= maxLength);
@@ -68460,7 +68460,7 @@ var Proto6 = {
     };
   }
 };
-var identityPath = (path12) => path12;
+var identityPath = (path14) => path14;
 function makeProvider(state, load) {
   const self = Object.create(Proto6);
   self.state = state;
@@ -68473,7 +68473,7 @@ function makeSource(get6, transform4) {
     get: get6,
     transform: transform4
   };
-  return makeProvider(state, (path12) => state.get(state.transform(path12)));
+  return makeProvider(state, (path14) => state.get(state.transform(path14)));
 }
 function make31(get6) {
   return makeSource(get6, identityPath);
@@ -68488,7 +68488,7 @@ function fromEnv(options) {
   };
   const preserveEmptyStrings = options?.preserveEmptyStrings === true;
   const trie = buildEnvTrie(env);
-  return make31((path12) => succeed6(nodeAtEnv(trie, env, path12, preserveEmptyStrings)));
+  return make31((path14) => succeed6(nodeAtEnv(trie, env, path14, preserveEmptyStrings)));
 }
 function buildEnvTrie(env) {
   const trie = {};
@@ -68504,10 +68504,10 @@ function buildEnvTrie(env) {
   return trie;
 }
 var NUMERIC_INDEX = /^(0|[1-9][0-9]*)$/;
-function nodeAtEnv(trie, env, path12, preserveEmptyStrings) {
-  const key = path12.map(String).join("_");
+function nodeAtEnv(trie, env, path14, preserveEmptyStrings) {
+  const key = path14.map(String).join("_");
   const leafValue = emptyStringAsMissing(env[key], preserveEmptyStrings);
-  const trieNode = trieNodeAt(trie, path12);
+  const trieNode = trieNodeAt(trie, path14);
   const children = trieNode?.children ? Object.keys(trieNode.children) : [];
   if (children.length === 0) {
     return leafValue === void 0 ? void 0 : makeValue(leafValue);
@@ -68519,10 +68519,10 @@ function nodeAtEnv(trie, env, path12, preserveEmptyStrings) {
   }
   return makeRecord(new Set(children), leafValue);
 }
-function trieNodeAt(root, path12) {
-  if (path12.length === 0) return root;
+function trieNodeAt(root, path14) {
+  if (path14.length === 0) return root;
   let node = root;
-  for (const seg of path12) {
+  for (const seg of path14) {
     node = node?.children?.[String(seg)];
     if (!node) return void 0;
   }
@@ -68633,7 +68633,7 @@ var handleBadArgument = (method) => (err) => badArgument({
 });
 var access2 = /* @__PURE__ */ (() => {
   const nodeAccess = /* @__PURE__ */ effectify(NFS.access, /* @__PURE__ */ handleErrnoException("FileSystem", "access"), /* @__PURE__ */ handleBadArgument("access"));
-  return (path12, options) => {
+  return (path14, options) => {
     let mode = NFS.constants.F_OK;
     if (options?.readable) {
       mode |= NFS.constants.R_OK;
@@ -68641,7 +68641,7 @@ var access2 = /* @__PURE__ */ (() => {
     if (options?.writable) {
       mode |= NFS.constants.W_OK;
     }
-    return nodeAccess(path12, mode);
+    return nodeAccess(path14, mode);
   };
 })();
 var copy2 = /* @__PURE__ */ (() => {
@@ -68658,11 +68658,11 @@ var copyFile2 = /* @__PURE__ */ (() => {
 })();
 var chmod2 = /* @__PURE__ */ (() => {
   const nodeChmod = /* @__PURE__ */ effectify(NFS.chmod, /* @__PURE__ */ handleErrnoException("FileSystem", "chmod"), /* @__PURE__ */ handleBadArgument("chmod"));
-  return (path12, mode) => nodeChmod(path12, mode);
+  return (path14, mode) => nodeChmod(path14, mode);
 })();
 var chown2 = /* @__PURE__ */ (() => {
   const nodeChown = /* @__PURE__ */ effectify(NFS.chown, /* @__PURE__ */ handleErrnoException("FileSystem", "chown"), /* @__PURE__ */ handleBadArgument("chown"));
-  return (path12, uid, gid) => nodeChown(path12, uid, gid);
+  return (path14, uid, gid) => nodeChown(path14, uid, gid);
 })();
 var glob2 = /* @__PURE__ */ (() => {
   const nodeGlob = /* @__PURE__ */ effectify(NFS.glob, /* @__PURE__ */ handleErrnoException("FileSystem", "glob"), /* @__PURE__ */ handleBadArgument("glob"));
@@ -68677,7 +68677,7 @@ var link3 = /* @__PURE__ */ (() => {
 })();
 var makeDirectory = /* @__PURE__ */ (() => {
   const nodeMkdir = /* @__PURE__ */ effectify(NFS.mkdir, /* @__PURE__ */ handleErrnoException("FileSystem", "makeDirectory"), /* @__PURE__ */ handleBadArgument("makeDirectory"));
-  return (path12, options) => nodeMkdir(path12, {
+  return (path14, options) => nodeMkdir(path14, {
     recursive: options?.recursive ?? false,
     mode: options?.mode
   });
@@ -68693,7 +68693,7 @@ var makeTempDirectoryFactory = (method) => {
 var makeTempDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectory");
 var removeFactory = (method) => {
   const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
-  return (path12, options) => nodeRm(path12, {
+  return (path14, options) => nodeRm(path14, {
     recursive: options?.recursive ?? false,
     force: options?.force ?? false
   });
@@ -68709,7 +68709,7 @@ var makeTempDirectoryScoped = /* @__PURE__ */ (() => {
 var openFactory = (method) => {
   const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
   const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
-  return (path12, options) => pipe(acquireRelease2(nodeOpen(path12, options?.flag ?? "r", options?.mode), (fd) => orDie3(nodeClose(fd))), map7((fd) => makeFile(FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
+  return (path14, options) => pipe(acquireRelease2(nodeOpen(path14, options?.flag ?? "r", options?.mode), (fd) => orDie3(nodeClose(fd))), map7((fd) => makeFile(FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
 };
 var open2 = /* @__PURE__ */ openFactory("open");
 var makeFile = /* @__PURE__ */ (() => {
@@ -68850,17 +68850,17 @@ var makeTempFileScoped = /* @__PURE__ */ (() => {
     recursive: true
   })));
 })();
-var readDirectory = (path12, options) => tryPromise2({
-  try: () => NFS.promises.readdir(path12, options),
-  catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path12])
+var readDirectory = (path14, options) => tryPromise2({
+  try: () => NFS.promises.readdir(path14, options),
+  catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path14])
 });
-var readFile2 = (path12) => callback2((resume, signal) => {
+var readFile2 = (path14) => callback2((resume, signal) => {
   try {
-    NFS.readFile(path12, {
+    NFS.readFile(path14, {
       signal
     }, (err, data) => {
       if (err) {
-        resume(fail6(handleErrnoException("FileSystem", "readFile")(err, [path12])));
+        resume(fail6(handleErrnoException("FileSystem", "readFile")(err, [path14])));
       } else {
         resume(succeed6(data));
       }
@@ -68871,11 +68871,11 @@ var readFile2 = (path12) => callback2((resume, signal) => {
 });
 var readLink = /* @__PURE__ */ (() => {
   const nodeReadLink = /* @__PURE__ */ effectify(NFS.readlink, /* @__PURE__ */ handleErrnoException("FileSystem", "readLink"), /* @__PURE__ */ handleBadArgument("readLink"));
-  return (path12) => nodeReadLink(path12);
+  return (path14) => nodeReadLink(path14);
 })();
 var realPath = /* @__PURE__ */ (() => {
   const nodeRealPath = /* @__PURE__ */ effectify(NFS.realpath, /* @__PURE__ */ handleErrnoException("FileSystem", "realPath"), /* @__PURE__ */ handleBadArgument("realPath"));
-  return (path12) => nodeRealPath(path12);
+  return (path14) => nodeRealPath(path14);
 })();
 var rename2 = /* @__PURE__ */ (() => {
   const nodeRename = /* @__PURE__ */ effectify(NFS.rename, /* @__PURE__ */ handleErrnoException("FileSystem", "rename"), /* @__PURE__ */ handleBadArgument("rename"));
@@ -68899,35 +68899,35 @@ var makeFileInfo = (stat3) => ({
 });
 var stat2 = /* @__PURE__ */ (() => {
   const nodeStat = /* @__PURE__ */ effectify(NFS.stat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
-  return (path12) => map7(nodeStat(path12), makeFileInfo);
+  return (path14) => map7(nodeStat(path14), makeFileInfo);
 })();
 var symlink2 = /* @__PURE__ */ (() => {
   const nodeSymlink = /* @__PURE__ */ effectify(NFS.symlink, /* @__PURE__ */ handleErrnoException("FileSystem", "symlink"), /* @__PURE__ */ handleBadArgument("symlink"));
-  return (target, path12) => nodeSymlink(target, path12);
+  return (target, path14) => nodeSymlink(target, path14);
 })();
 var truncate3 = /* @__PURE__ */ (() => {
   const nodeTruncate = /* @__PURE__ */ effectify(NFS.truncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
-  return (path12, length) => nodeTruncate(path12, length !== void 0 ? Number(length) : void 0);
+  return (path14, length) => nodeTruncate(path14, length !== void 0 ? Number(length) : void 0);
 })();
 var utimes2 = /* @__PURE__ */ (() => {
   const nodeUtimes = /* @__PURE__ */ effectify(NFS.utimes, /* @__PURE__ */ handleErrnoException("FileSystem", "utime"), /* @__PURE__ */ handleBadArgument("utime"));
-  return (path12, atime, mtime) => nodeUtimes(path12, atime, mtime);
+  return (path14, atime, mtime) => nodeUtimes(path14, atime, mtime);
 })();
-var watchNode = (path12) => callback3((queue) => acquireRelease2(sync3(() => {
-  const watcher = NFS.watch(path12, {
+var watchNode = (path14) => callback3((queue) => acquireRelease2(sync3(() => {
+  const watcher = NFS.watch(path14, {
     recursive: true
-  }, (event, path13) => {
-    if (!path13) return;
+  }, (event, path15) => {
+    if (!path15) return;
     switch (event) {
       case "rename": {
-        runFork2(matchEffect3(stat2(path13), {
+        runFork2(matchEffect3(stat2(path15), {
           onSuccess: (_) => offer(queue, {
             _tag: "Create",
-            path: path13
+            path: path15
           }),
           onFailure: (_) => offer(queue, {
             _tag: "Remove",
-            path: path13
+            path: path15
           })
         }));
         return;
@@ -68935,7 +68935,7 @@ var watchNode = (path12) => callback3((queue) => acquireRelease2(sync3(() => {
       case "change": {
         offerUnsafe(queue, {
           _tag: "Update",
-          path: path13
+          path: path15
         });
         return;
       }
@@ -68946,7 +68946,7 @@ var watchNode = (path12) => callback3((queue) => acquireRelease2(sync3(() => {
       module: "FileSystem",
       _tag: "Unknown",
       method: "watch",
-      pathOrDescriptor: path12,
+      pathOrDescriptor: path14,
       cause: error2
     })));
   });
@@ -68955,16 +68955,16 @@ var watchNode = (path12) => callback3((queue) => acquireRelease2(sync3(() => {
   });
   return watcher;
 }), (watcher) => sync3(() => watcher.close())));
-var watch2 = (backend, path12) => stat2(path12).pipe(map7((stat3) => backend.pipe(flatMap((_) => _.register(path12, stat3)), getOrElse(() => watchNode(path12)))), unwrap4);
-var writeFile2 = (path12, data, options) => callback2((resume, signal) => {
+var watch2 = (backend, path14) => stat2(path14).pipe(map7((stat3) => backend.pipe(flatMap((_) => _.register(path14, stat3)), getOrElse(() => watchNode(path14)))), unwrap4);
+var writeFile2 = (path14, data, options) => callback2((resume, signal) => {
   try {
-    NFS.writeFile(path12, data, {
+    NFS.writeFile(path14, data, {
       signal,
       flag: options?.flag,
       mode: options?.mode
     }, (err) => {
       if (err) {
-        resume(fail6(handleErrnoException("FileSystem", "writeFile")(err, [path12])));
+        resume(fail6(handleErrnoException("FileSystem", "writeFile")(err, [path14])));
       } else {
         resume(void_5);
       }
@@ -68997,8 +68997,8 @@ var makeFileSystem = /* @__PURE__ */ map7(/* @__PURE__ */ serviceOption2(WatchBa
   symlink: symlink2,
   truncate: truncate3,
   utimes: utimes2,
-  watch(path12) {
-    return watch2(backend, path12);
+  watch(path14) {
+    return watch2(backend, path14);
   },
   writeFile: writeFile2
 }));
@@ -69139,8 +69139,8 @@ var fromFileUrl2 = (url) => try_3({
     cause
   })
 });
-var toFileUrl2 = (path12) => try_3({
-  try: () => NodeUrl.pathToFileURL(path12),
+var toFileUrl2 = (path14) => try_3({
+  try: () => NodeUrl.pathToFileURL(path14),
   catch: (cause) => new BadArgument({
     module: "Path",
     method: "toFileUrl",
@@ -69728,8 +69728,8 @@ var choice = (choices) => {
 };
 var path = (pathType, mustExist) => makePrimitive2("Path", fnUntraced2(function* (value3) {
   const fs4 = yield* FileSystem;
-  const path12 = yield* Path;
-  const absolutePath = path12.isAbsolute(value3) ? value3 : path12.resolve(value3);
+  const path14 = yield* Path;
+  const absolutePath = path14.isAbsolute(value3) ? value3 : path14.resolve(value3);
   const exists2 = yield* mapError3(fs4.exists(absolutePath), (error2) => `Failed to check path existence: ${error2.message}`);
   if (mustExist === true && !exists2) {
     return yield* fail6(`Path does not exist: ${absolutePath}`);
@@ -69748,8 +69748,8 @@ var path = (pathType, mustExist) => makePrimitive2("Path", fnUntraced2(function*
 var redacted = /* @__PURE__ */ makePrimitive2("Redacted", (value3) => succeed6(make9(value3)));
 var fileText = /* @__PURE__ */ makePrimitive2("FileText", /* @__PURE__ */ fnUntraced2(function* (filePath) {
   const fs4 = yield* FileSystem;
-  const path12 = yield* Path;
-  const absolutePath = path12.isAbsolute(filePath) ? filePath : path12.resolve(filePath);
+  const path14 = yield* Path;
+  const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.resolve(filePath);
   const exists2 = yield* mapError3(fs4.exists(absolutePath), (error2) => `Failed to check file existence: ${error2.message}`);
   if (!exists2) {
     return yield* fail6(`File does not exist: ${absolutePath}`);
@@ -74244,20 +74244,20 @@ var withSubcommands = /* @__PURE__ */ dual(2, (self, subcommands) => {
       }
     });
   });
-  const handle = fnUntraced2(function* (input, path12) {
+  const handle = fnUntraced2(function* (input, path14) {
     const internal = input;
     const selectedSubcommand = internal[SubcommandStateSymbol];
     if (selectedSubcommand) {
       const child = byName.get(selectedSubcommand.name);
       if (!child) {
         return yield* new ShowHelp({
-          commandPath: path12,
+          commandPath: path14,
           errors: []
         });
       }
-      return yield* child.handle(selectedSubcommand.result, [...path12, child.name]).pipe(provideService2(impl.service, input));
+      return yield* child.handle(selectedSubcommand.result, [...path14, child.name]).pipe(provideService2(impl.service, input));
     }
-    return yield* impl.handle(input, path12);
+    return yield* impl.handle(input, path14);
   });
   return makeCommand({
     name: impl.name,
@@ -74362,7 +74362,7 @@ var mapHandler = (self, f) => {
   const impl = toImpl(self);
   return makeCommand({
     ...impl,
-    handle: (input, path12) => f(impl.handle(input, path12), input)
+    handle: (input, path14) => f(impl.handle(input, path14), input)
   });
 };
 var provide6 = /* @__PURE__ */ dual((args2) => isCommand(args2[0]), (self, layer14, options) => mapHandler(self, (handler, input) => provide4(handler, typeof layer14 === "function" ? layer14(input) : layer14, options)));
@@ -74518,10 +74518,9 @@ var runWith2 = (command, config) => {
 
 // dist/config.js
 import * as fs from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 
-// dist/core/DocSummaries.js
-import { hash as hashHex } from "node:crypto";
+// dist/core/summaries/DocSummaries.js
 var DEFAULT_NAMING = {
   dirSummary: "_SUMMARY.md",
   fileSummarySuffix: ".summary.md"
@@ -74535,9 +74534,8 @@ var countLines = (content) => {
   }
   return lines2.length;
 };
-var isSummaryFile = (path12, naming = DEFAULT_NAMING) => path12.endsWith(naming.fileSummarySuffix);
-var summaryPathFor = (path12, naming = DEFAULT_NAMING) => path12.replace(/\.md$/, naming.fileSummarySuffix);
-var hashContent = (content) => hashHex("sha256", content, "hex");
+var isSummaryFile = (path14, naming = DEFAULT_NAMING) => path14.endsWith(naming.fileSummarySuffix);
+var summaryPathFor = (path14, naming = DEFAULT_NAMING) => path14.replace(/\.md$/, naming.fileSummarySuffix);
 var stripSourceHash = (summaryContent) => {
   if (!HASH_RE.test(summaryContent)) {
     return summaryContent;
@@ -74661,11 +74659,17 @@ var compile = (pattern) => {
   }
   return new RegExp(`^${re}$`);
 };
-var matchesGlob = (path12, pattern) => globToRegExp(pattern).test(path12);
-var matchesAny = (path12, patterns) => patterns.some((pattern) => matchesGlob(path12, pattern));
+var matchesGlob = (path14, pattern) => globToRegExp(pattern).test(path14);
+var matchesAny = (path14, patterns) => patterns.some((pattern) => matchesGlob(path14, pattern));
 
 // dist/core/paths.js
+import * as nodePath from "node:path";
+var path5 = nodePath.posix;
 var toPosix = (p) => p.replaceAll("\\", "/");
+var isWithinBase = (candidate, base2) => {
+  const rel = path5.relative(base2, candidate);
+  return !rel.startsWith("..") && !path5.isAbsolute(rel);
+};
 
 // dist/config.js
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -74678,13 +74682,13 @@ var parseRcJson = (text2, file4) => {
   }
 };
 var readRawConfig = (cwd, explicitPath) => {
-  const candidates = explicitPath ? [path5.resolve(cwd, explicitPath)] : CONFIG_FILENAMES.map((f) => path5.join(cwd, f));
+  const candidates = explicitPath ? [path6.resolve(cwd, explicitPath)] : CONFIG_FILENAMES.map((f) => path6.join(cwd, f));
   for (const file4 of candidates) {
     if (fs.existsSync(file4)) {
       return { file: file4, raw: parseRcJson(fs.readFileSync(file4, "utf8"), file4) };
     }
   }
-  const pkgPath = path5.join(cwd, "package.json");
+  const pkgPath = path6.join(cwd, "package.json");
   if (fs.existsSync(pkgPath)) {
     const pkg = parseRcJson(fs.readFileSync(pkgPath, "utf8"), pkgPath);
     if (isRecord(pkg) && isRecord(pkg["cairn"])) {
@@ -74694,7 +74698,7 @@ var readRawConfig = (cwd, explicitPath) => {
   return null;
 };
 var resolveExtendsTarget = (cwd, specifier, fromFile, visited, acc) => {
-  const resolved = path5.isAbsolute(specifier) ? specifier : path5.resolve(path5.dirname(fromFile), specifier);
+  const resolved = path6.isAbsolute(specifier) ? specifier : path6.resolve(path6.dirname(fromFile), specifier);
   if (!fs.existsSync(resolved)) {
     throw new Error(`cairn: invalid config in ${fromFile}: extends target not found: ${specifier} (resolved to ${resolved})`);
   }
@@ -74739,13 +74743,13 @@ var expandOne = (cwd, pattern) => {
         continue;
       }
       if (!hasGlob(segment)) {
-        next.push(path5.join(dir2, segment));
+        next.push(path6.join(dir2, segment));
         continue;
       }
       const re = globToRegExp(segment);
       for (const entry of readDirsSafe(dir2)) {
         if (re.test(entry)) {
-          next.push(path5.join(dir2, entry));
+          next.push(path6.join(dir2, entry));
         }
       }
     }
@@ -74771,7 +74775,7 @@ var readDirsSafe = (dir2) => {
 var descendantDirs = (dir2) => {
   const out = [];
   for (const name of readDirsSafe(dir2)) {
-    const child = path5.join(dir2, name);
+    const child = path6.join(dir2, name);
     out.push(child, ...descendantDirs(child));
   }
   return out;
@@ -74788,7 +74792,7 @@ var expandRoots = (cwd, patterns) => {
 
 // dist/init/generate.js
 import * as fs2 from "node:fs";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 
 // dist/init/content.js
 var CONVENTION_BODY = `# Documentation summary convention
@@ -74950,7 +74954,7 @@ var AGENTS_START = "<!-- cairn:start -->";
 var AGENTS_END = "<!-- cairn:end -->";
 var rootsToGlobs = (roots) => roots.map((r) => `${r.replace(/\/+$/, "")}/**`);
 var ensureDir = (file4) => {
-  fs2.mkdirSync(path6.dirname(file4), { recursive: true });
+  fs2.mkdirSync(path7.dirname(file4), { recursive: true });
 };
 var write2 = (file4, content, written) => {
   ensureDir(file4);
@@ -74981,7 +74985,7 @@ var skillFile = () => [
   SKILL_BODY
 ].join("\n");
 var upsertAgentsBlock = (cwd, written) => {
-  const file4 = path6.join(cwd, "AGENTS.md");
+  const file4 = path7.join(cwd, "AGENTS.md");
   const block = `${AGENTS_START}
 
 ${CONVENTION_BODY.trimEnd()}
@@ -75009,7 +75013,7 @@ ${block}
   written.push(file4);
 };
 var upsertClaudeMdImport = (cwd, written, skipped) => {
-  const file4 = path6.join(cwd, "CLAUDE.md");
+  const file4 = path7.join(cwd, "CLAUDE.md");
   const block = `${AGENTS_START}
 @AGENTS.md
 ${AGENTS_END}`;
@@ -75047,17 +75051,17 @@ var runInit = ({ agent, cwd, roots }) => {
   const doCopilot = agent === "copilot" || agent === "all";
   const doAgents = agent === "agents" || agent === "opencode" || agent === "all";
   if (doClaude) {
-    write2(path6.join(cwd, ".claude/rules/docs-summaries.md"), claudeRule(globs), written);
-    write2(path6.join(cwd, ".claude/skills/cairn/SKILL.md"), skillFile(), written);
+    write2(path7.join(cwd, ".claude/rules/docs-summaries.md"), claudeRule(globs), written);
+    write2(path7.join(cwd, ".claude/skills/cairn/SKILL.md"), skillFile(), written);
     upsertClaudeMdImport(cwd, written, skipped);
   }
   if (doCopilot) {
-    write2(path6.join(cwd, ".github/instructions/docs-summaries.instructions.md"), copilotInstructions(globs), written);
+    write2(path7.join(cwd, ".github/instructions/docs-summaries.instructions.md"), copilotInstructions(globs), written);
   }
   if (doAgents || doClaude || doCopilot) {
     upsertAgentsBlock(cwd, written);
   }
-  const rc = path6.join(cwd, ".cairnrc.json");
+  const rc = path7.join(cwd, ".cairnrc.json");
   if (fs2.existsSync(rc)) {
     skipped.push(rc);
   } else {
@@ -75071,7 +75075,7 @@ var DocsFs = class extends Context_exports.Service()("DocsFs") {
 };
 var DocsFsLive = Layer_exports.effect(DocsFs, Effect_exports.gen(function* () {
   const fs4 = yield* FileSystem_exports.FileSystem;
-  const path12 = yield* Path_exports.Path;
+  const path14 = yield* Path_exports.Path;
   const STAT_CONCURRENCY = 32;
   const listFiles = (roots) => Effect_exports.gen(function* () {
     const out = [];
@@ -75082,7 +75086,7 @@ var DocsFsLive = Layer_exports.effect(DocsFs, Effect_exports.gen(function* () {
       }
       const entries3 = yield* fs4.readDirectory(root, { recursive: true });
       const abses = yield* Effect_exports.forEach(entries3, (entry) => {
-        const abs2 = path12.join(root, entry);
+        const abs2 = path14.join(root, entry);
         return fs4.stat(abs2).pipe(Effect_exports.map((info2) => info2.type === "File" ? abs2 : null));
       }, { concurrency: STAT_CONCURRENCY });
       for (const abs2 of abses) {
@@ -75098,7 +75102,7 @@ var DocsFsLive = Layer_exports.effect(DocsFs, Effect_exports.gen(function* () {
     sizeBytes: Number(info2.size)
   })), Effect_exports.orDie);
   const writeFile3 = (abs2, content) => Effect_exports.gen(function* () {
-    yield* fs4.makeDirectory(path12.dirname(abs2), { recursive: true });
+    yield* fs4.makeDirectory(path14.dirname(abs2), { recursive: true });
     yield* fs4.writeFileString(abs2, content);
   }).pipe(Effect_exports.orDie);
   return {
@@ -75111,16 +75115,184 @@ var DocsFsLive = Layer_exports.effect(DocsFs, Effect_exports.gen(function* () {
   };
 }));
 
-// dist/program/CheckLinks.js
-import * as nodePath2 from "node:path";
+// dist/program/links/CheckLinks.js
+import * as nodePath3 from "node:path";
 
-// dist/core/MarkdownLinks.js
-import * as nodePath from "node:path";
-var path7 = nodePath.posix;
+// node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/regex.js
+var regex = /[\0-\x1F!-,\.\/:-@\[-\^`\{-\xA9\xAB-\xB4\xB6-\xB9\xBB-\xBF\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0378\u0379\u037E\u0380-\u0385\u0387\u038B\u038D\u03A2\u03F6\u0482\u0530\u0557\u0558\u055A-\u055F\u0589-\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05EB-\u05EE\u05F3-\u060F\u061B-\u061F\u066A-\u066D\u06D4\u06DD\u06DE\u06E9\u06FD\u06FE\u0700-\u070F\u074B\u074C\u07B2-\u07BF\u07F6-\u07F9\u07FB\u07FC\u07FE\u07FF\u082E-\u083F\u085C-\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0964\u0965\u0970\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09F2-\u09FB\u09FD\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF0-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B70\u0B72-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BF0-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C7F\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D4F-\u0D53\u0D58-\u0D5E\u0D64\u0D65\u0D70-\u0D79\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF4-\u0E00\u0E3B-\u0E3F\u0E4F\u0E5A-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F01-\u0F17\u0F1A-\u0F1F\u0F2A-\u0F34\u0F36\u0F38\u0F3A-\u0F3D\u0F48\u0F6D-\u0F70\u0F85\u0F98\u0FBD-\u0FC5\u0FC7-\u0FFF\u104A-\u104F\u109E\u109F\u10C6\u10C8-\u10CC\u10CE\u10CF\u10FB\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u1360-\u137F\u1390-\u139F\u13F6\u13F7\u13FE-\u1400\u166D\u166E\u1680\u169B-\u169F\u16EB-\u16ED\u16F9-\u16FF\u170D\u1715-\u171F\u1735-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17D4-\u17D6\u17D8-\u17DB\u17DE\u17DF\u17EA-\u180A\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u1945\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DA-\u19FF\u1A1C-\u1A1F\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1AA6\u1AA8-\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B5A-\u1B6A\u1B74-\u1B7F\u1BF4-\u1BFF\u1C38-\u1C3F\u1C4A-\u1C4C\u1C7E\u1C7F\u1C89-\u1C8F\u1CBB\u1CBC\u1CC0-\u1CCF\u1CD3\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FBD\u1FBF-\u1FC1\u1FC5\u1FCD-\u1FCF\u1FD4\u1FD5\u1FDC-\u1FDF\u1FED-\u1FF1\u1FF5\u1FFD-\u203E\u2041-\u2053\u2055-\u2070\u2072-\u207E\u2080-\u208F\u209D-\u20CF\u20F1-\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F-\u215F\u2189-\u24B5\u24EA-\u2BFF\u2C2F\u2C5F\u2CE5-\u2CEA\u2CF4-\u2CFF\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D70-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E00-\u2E2E\u2E30-\u3004\u3008-\u3020\u3030\u3036\u3037\u303D-\u3040\u3097\u3098\u309B\u309C\u30A0\u30FB\u3100-\u3104\u3130\u318F-\u319F\u31C0-\u31EF\u3200-\u33FF\u4DC0-\u4DFF\u9FFD-\u9FFF\uA48D-\uA4CF\uA4FE\uA4FF\uA60D-\uA60F\uA62C-\uA63F\uA673\uA67E\uA6F2-\uA716\uA720\uA721\uA789\uA78A\uA7C0\uA7C1\uA7CB-\uA7F4\uA828-\uA82B\uA82D-\uA83F\uA874-\uA87F\uA8C6-\uA8CF\uA8DA-\uA8DF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA954-\uA95F\uA97D-\uA97F\uA9C1-\uA9CE\uA9DA-\uA9DF\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A-\uAA5F\uAA77-\uAA79\uAAC3-\uAADA\uAADE\uAADF\uAAF0\uAAF1\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB5B\uAB6A-\uAB6F\uABEB\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB29\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBB2-\uFBD2\uFD3E-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFC-\uFDFF\uFE10-\uFE1F\uFE30-\uFE32\uFE35-\uFE4C\uFE50-\uFE6F\uFE75\uFEFD-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF3E\uFF40\uFF5B-\uFF65\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDD3F\uDD75-\uDDFC\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEE1-\uDEFF\uDF20-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDF9F\uDFC4-\uDFC7\uDFD0\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56-\uDC5F\uDC77-\uDC7F\uDC9F-\uDCDF\uDCF3\uDCF6-\uDCFF\uDD16-\uDD1F\uDD3A-\uDD7F\uDDB8-\uDDBD\uDDC0-\uDDFF\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE40-\uDE5F\uDE7D-\uDE7F\uDE9D-\uDEBF\uDEC8\uDEE7-\uDEFF\uDF36-\uDF3F\uDF56-\uDF5F\uDF73-\uDF7F\uDF92-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCFF\uDD28-\uDD2F\uDD3A-\uDE7F\uDEAA\uDEAD-\uDEAF\uDEB2-\uDEFF\uDF1D-\uDF26\uDF28-\uDF2F\uDF51-\uDFAF\uDFC5-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC47-\uDC65\uDC70-\uDC7E\uDCBB-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD40-\uDD43\uDD48-\uDD4F\uDD74\uDD75\uDD77-\uDD7F\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDFF\uDE12\uDE38-\uDE3D\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEA9-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC4B-\uDC4F\uDC5A-\uDC5D\uDC62-\uDC7F\uDCC6\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDC1-\uDDD7\uDDDE-\uDDFF\uDE41-\uDE43\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF3A-\uDFFF]|\uD806[\uDC3B-\uDC9F\uDCEA-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD44-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE2\uDDE5-\uDDFF\uDE3F-\uDE46\uDE48-\uDE4F\uDE9A-\uDE9C\uDE9E-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC41-\uDC4F\uDC5A-\uDC71\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF7-\uDFAF\uDFB1-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83D\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDECF\uDEEE\uDEEF\uDEF5-\uDEFF\uDF37-\uDF3F\uDF44-\uDF4F\uDF5A-\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE80-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE2\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A-\uDC9C\uDC9F-\uDFFF]|\uD834[\uDC00-\uDD64\uDD6A-\uDD6C\uDD73-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDE41\uDE45-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3\uDFCC\uDFCD]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD4F-\uDEBF\uDEFA-\uDFFF]|\uD83A[\uDCC5-\uDCCF\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDFFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDFFF]|\uD83C[\uDC00-\uDD2F\uDD4A-\uDD4F\uDD6A-\uDD6F\uDD8A-\uDFFF]|\uD83E[\uDC00-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]/g;
+
+// node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/index.js
+var own = Object.hasOwnProperty;
+var BananaSlug = class {
+  /**
+   * Create a new slug class.
+   */
+  constructor() {
+    this.occurrences;
+    this.reset();
+  }
+  /**
+   * Generate a unique slug.
+  *
+  * Tracks previously generated slugs: repeated calls with the same value
+  * will result in different slugs.
+  * Use the `slug` function to get same slugs.
+   *
+   * @param  {string} value
+   *   String of text to slugify
+   * @param  {boolean} [maintainCase=false]
+   *   Keep the current case, otherwise make all lowercase
+   * @return {string}
+   *   A unique slug string
+   */
+  slug(value3, maintainCase) {
+    const self = this;
+    let result3 = slug(value3, maintainCase === true);
+    const originalSlug = result3;
+    while (own.call(self.occurrences, result3)) {
+      self.occurrences[originalSlug]++;
+      result3 = originalSlug + "-" + self.occurrences[originalSlug];
+    }
+    self.occurrences[result3] = 0;
+    return result3;
+  }
+  /**
+   * Reset - Forget all previous slugs
+   *
+   * @return void
+   */
+  reset() {
+    this.occurrences = /* @__PURE__ */ Object.create(null);
+  }
+};
+function slug(value3, maintainCase) {
+  if (typeof value3 !== "string") return "";
+  if (!maintainCase) value3 = value3.toLowerCase();
+  return value3.replace(regex, "").replace(/ /g, "-");
+}
+
+// dist/core/links/markdownFences.js
+var fenceOpenMarker = (line) => {
+  const trimmed = line.trimStart();
+  if (trimmed.startsWith("```")) {
+    return "```";
+  }
+  if (trimmed.startsWith("~~~")) {
+    return "~~~";
+  }
+  return null;
+};
+var isFenceClose = (line, marker) => line.trim() === marker;
+var maskFencedCode = (content) => {
+  const lines2 = content.split("\n");
+  let i = 0;
+  while (i < lines2.length) {
+    const marker = fenceOpenMarker(lines2[i] ?? "");
+    if (marker === null) {
+      i += 1;
+      continue;
+    }
+    let j = i + 1;
+    while (j < lines2.length && !isFenceClose(lines2[j] ?? "", marker)) {
+      j += 1;
+    }
+    const end = j < lines2.length ? j : lines2.length - 1;
+    for (let k = i; k <= end; k += 1) {
+      lines2[k] = " ".repeat((lines2[k] ?? "").length);
+    }
+    i = end + 1;
+  }
+  return lines2.join("\n");
+};
+
+// dist/core/links/Anchors.js
+var ATX_RE = /^(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+var SETEXT_RE = /^(=+|-+)[ \t]*$/;
+var HTML_ANCHOR_RE = /<a\s+(?:[^>]*?\s)?(?:name|id)=["']([^"']+)["']/gi;
+var HEADING_LINK_RE = /!?\[([^\]]*)\]\([^)\s]+(?:\s+"[^"]*")?\)/g;
+var ENTITY_MAP = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  quot: '"'
+};
+var decodeEntities = (text2) => text2.replaceAll(/&(#x?[0-9a-f]+|[a-z]+);/gi, (whole, body) => {
+  if (body.startsWith("#")) {
+    const codePoint = body[1]?.toLowerCase() === "x" ? Number.parseInt(body.slice(2), 16) : Math.trunc(Number(body.slice(1)));
+    return Number.isFinite(codePoint) ? String.fromCodePoint(codePoint) : whole;
+  }
+  return ENTITY_MAP[body.toLowerCase()] ?? whole;
+});
+var flattenInlineLinks = (headingText) => headingText.replaceAll(HEADING_LINK_RE, (_whole, text2) => text2);
+var extractHeadingTexts = (masked) => {
+  const lines2 = masked.split("\n");
+  const headings2 = [];
+  for (const [i, line] of lines2.entries()) {
+    const atx = ATX_RE.exec(line ?? "");
+    if (atx) {
+      headings2.push(atx[2] ?? "");
+      continue;
+    }
+    if (i > 0 && SETEXT_RE.test(line ?? "")) {
+      const prev = lines2[i - 1] ?? "";
+      if (prev.trim() !== "" && !ATX_RE.test(prev) && !SETEXT_RE.test(prev)) {
+        headings2.push(prev.trim());
+      }
+    }
+  }
+  return headings2;
+};
+var extractAnchors = (content) => {
+  const masked = maskFencedCode(content);
+  const slugger = new BananaSlug();
+  const anchors = /* @__PURE__ */ new Set();
+  for (const raw of extractHeadingTexts(masked)) {
+    const flattened = decodeEntities(flattenInlineLinks(raw));
+    anchors.add(slugger.slug(flattened));
+  }
+  for (const match8 of masked.matchAll(HTML_ANCHOR_RE)) {
+    if (match8[1]) {
+      anchors.add(match8[1]);
+    }
+  }
+  return anchors;
+};
+var normalizeAnchor = (anchor) => {
+  try {
+    return decodeURIComponent(anchor);
+  } catch {
+    return anchor;
+  }
+};
+var LINE_ANCHOR_RE = /^L(\d+)(?:-L(\d+))?$/;
+var parseLineAnchor = (anchor) => {
+  const match8 = LINE_ANCHOR_RE.exec(anchor);
+  if (!match8) {
+    return null;
+  }
+  const start = Number(match8[1]);
+  const end = match8[2] === void 0 ? start : Number(match8[2]);
+  return start >= 1 && end >= start ? { end, start } : null;
+};
+var isValidLineAnchor = (range2, lineCount) => range2.end <= lineCount;
+var MAX_LISTED_ANCHORS = 8;
+var describeAnchors = (anchors) => {
+  if (anchors.size === 0) {
+    return "target has no headings or anchors";
+  }
+  const list = [...anchors];
+  const shown = list.slice(0, MAX_LISTED_ANCHORS);
+  const suffix = list.length > MAX_LISTED_ANCHORS ? `, and ${list.length - MAX_LISTED_ANCHORS} more` : "";
+  return `available anchors: ${shown.join(", ")}${suffix}`;
+};
+
+// dist/core/links/MarkdownLinks.js
+import * as nodePath2 from "node:path";
+var path8 = nodePath2.posix;
 var LINK_RE = /!?\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
-var FENCED_CODE_RE = /(^|\n)[ \t]*(```|~~~)[\s\S]*?\n[ \t]*\2[ \t]*(?=\n|$)/g;
 var INLINE_CODE_RE = /`[^`\n]*`/g;
-var stripCode = (content) => content.replaceAll(FENCED_CODE_RE, (block) => block.replaceAll(/[^\n]/g, " ")).replaceAll(INLINE_CODE_RE, (block) => " ".repeat(block.length));
+var stripCode = (content) => maskFencedCode(content).replaceAll(INLINE_CODE_RE, (block) => " ".repeat(block.length));
 var LINK_DEF_RE = /^[ \t]*\[([^\]]+)\]:[ \t]*<?([^>\s]+)>?/gm;
 var extractLinks = (content) => {
   const links = [];
@@ -75136,13 +75308,29 @@ var extractLinkDefinitions = (content) => {
   }
   return defs;
 };
+var captureGroupStart = (match8) => (match8.index ?? 0) + match8[0].indexOf("[") + 1;
+var extractLinksPreservingText = (original, masked) => {
+  const links = [];
+  for (const match8 of masked.matchAll(LINK_RE)) {
+    const textStart = captureGroupStart(match8);
+    const textLength = match8[1]?.length ?? 0;
+    links.push({ target: match8[2] ?? "", text: original.slice(textStart, textStart + textLength) });
+  }
+  return links;
+};
+var extractLinkDefinitionsPreservingLabel = (original, masked) => {
+  const defs = [];
+  for (const match8 of masked.matchAll(LINK_DEF_RE)) {
+    const labelStart = captureGroupStart(match8);
+    const labelLength = match8[1]?.length ?? 0;
+    defs.push({ label: original.slice(labelStart, labelStart + labelLength), target: match8[2] ?? "" });
+  }
+  return defs;
+};
 var isCheckableTarget = (target) => {
   if (!target) {
     return false;
   }
-  if (target.startsWith("#")) {
-    return false;
-  }
   if (target.startsWith("//")) {
     return false;
   }
@@ -75151,11 +75339,45 @@ var isCheckableTarget = (target) => {
   }
   return true;
 };
-var stripAnchor = (target) => target.replace(/[#?].*$/, "");
+var parseTarget = (target) => {
+  const hashIdx = target.indexOf("#");
+  const rawPath = hashIdx === -1 ? target : target.slice(0, hashIdx);
+  const queryIdx = rawPath.indexOf("?");
+  return {
+    anchor: hashIdx === -1 ? null : target.slice(hashIdx + 1),
+    path: queryIdx === -1 ? rawPath : rawPath.slice(0, queryIdx)
+  };
+};
+var stripAnchor = (target) => parseTarget(target).path;
+var extractReferences = (content) => {
+  const masked = stripCode(content);
+  const candidates = [
+    ...extractLinks(masked),
+    ...extractLinkDefinitions(masked).map((def) => ({ target: def.target, text: "" }))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  for (const link4 of candidates) {
+    if (!isCheckableTarget(link4.target)) {
+      continue;
+    }
+    const { anchor, path: target } = parseTarget(link4.target);
+    if (target === "") {
+      continue;
+    }
+    const key = `${target}#${anchor ?? ""}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    refs.push({ anchor, target });
+  }
+  return refs;
+};
 var buildBasenameIndex = (absPaths) => {
   const index2 = /* @__PURE__ */ new Map();
   for (const abs2 of absPaths) {
-    const base2 = path7.basename(abs2);
+    const base2 = path8.basename(abs2);
     const bucket = index2.get(base2);
     if (bucket) {
       bucket.push(abs2);
@@ -75166,57 +75388,78 @@ var buildBasenameIndex = (absPaths) => {
   return index2;
 };
 var toRelative = (fromDir, toAbs) => {
-  const rel = path7.relative(fromDir, toAbs).split(path7.sep).join("/");
+  const rel = path8.relative(fromDir, toAbs).split(path8.sep).join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 };
 var suggestFix = ({ fromDir, index: index2, target }) => {
-  const base2 = path7.basename(stripAnchor(target));
+  const base2 = path8.basename(stripAnchor(target));
   const candidates = index2.get(base2);
   if (!candidates || candidates.length !== 1) {
     return null;
   }
   return toRelative(fromDir, candidates[0] ?? "");
 };
-var checkContent = ({ content, existsAbs, fileAbs, index: index2 }) => {
-  const fromDir = path7.dirname(fileAbs);
+var checkContent = ({ content, existsAbs, fileAbs, index: index2, inRoots = () => true }) => {
+  const fromDir = path8.dirname(fileAbs);
   const broken = [];
+  const pending = [];
   const masked = stripCode(content);
   const candidates = [
-    ...extractLinks(masked),
+    ...extractLinksPreservingText(content, masked),
     // Reference-style definitions are checked by their target too.
-    ...extractLinkDefinitions(masked).map((def) => ({ target: def.target, text: `[${def.label}]` }))
+    ...extractLinkDefinitionsPreservingLabel(content, masked).map((def) => ({
+      target: def.target,
+      text: `[${def.label}]`
+    }))
   ];
+  let sourceAnchors = null;
+  const getSourceAnchors = () => sourceAnchors ??= extractAnchors(content);
   for (const link4 of candidates) {
     if (!isCheckableTarget(link4.target)) {
       continue;
     }
-    const rel = stripAnchor(link4.target);
-    if (!rel) {
+    const { anchor, path: rel } = parseTarget(link4.target);
+    if (rel === "") {
+      if (anchor !== null && !getSourceAnchors().has(anchor)) {
+        broken.push({
+          detail: describeAnchors(getSourceAnchors()),
+          reason: "anchor",
+          target: link4.target,
+          text: link4.text
+        });
+      }
       continue;
     }
-    const abs2 = path7.resolve(fromDir, rel);
+    const abs2 = path8.resolve(fromDir, rel);
     if (existsAbs(abs2)) {
+      if (anchor !== null) {
+        pending.push({ anchor, fromDir, target: link4.target, targetAbs: abs2, text: link4.text });
+      }
+      continue;
+    }
+    if (!inRoots(abs2)) {
+      pending.push({ anchor, fromDir, target: link4.target, targetAbs: abs2, text: link4.text });
       continue;
     }
     const suggestion = index2 ? suggestFix({ fromDir, index: index2, target: link4.target }) : null;
-    broken.push(suggestion ? { suggestion, target: link4.target, text: link4.text } : { target: link4.target, text: link4.text });
+    broken.push(suggestion ? { reason: "path", suggestion, target: link4.target, text: link4.text } : { reason: "path", target: link4.target, text: link4.text });
   }
-  return broken;
+  return { broken, pending };
 };
 
 // dist/program/locale.js
 var pick3 = (locale, values2) => values2[locale];
 var enOnly = (value3) => ({ en: value3, fr: value3 });
 
-// dist/program/CheckLinks.js
-var path8 = nodePath2.posix;
+// dist/program/links/CheckLinks.js
+var path9 = nodePath3.posix;
 var withAncestors = (files) => {
   const set4 = new Set(files);
   for (const file4 of files) {
-    let dir2 = path8.dirname(file4);
+    let dir2 = path9.dirname(file4);
     while (!set4.has(dir2)) {
       set4.add(dir2);
-      const parent = path8.dirname(dir2);
+      const parent = path9.dirname(dir2);
       if (parent === dir2) {
         break;
       }
@@ -75264,24 +75507,110 @@ var formatLinkReport = (result3, options = {}) => {
   for (const { file: file4, links } of result3.broken) {
     lines2.push(`  ${file4}`);
     for (const link4 of links) {
-      const hint = link4.suggestion !== void 0 ? pick3(locale, { en: ` \u2192 suggestion: ${link4.suggestion}`, fr: ` \u2192 suggestion : ${link4.suggestion}` }) : pick3(locale, { en: " (no unique target)", fr: " (aucune cible unique)" });
-      lines2.push(`    \u2717 [${link4.text}](${link4.target})${hint}`);
+      lines2.push(`    \u2717 [${link4.text}](${link4.target})${linkHint(locale, link4)}`);
     }
   }
   return lines2;
 };
-var checkLinks = ({ fix, ignore: ignore4 = [], roots }) => Effect_exports.gen(function* () {
+var linkHint = (locale, link4) => {
+  if (link4.suggestion !== void 0) {
+    return pick3(locale, { en: ` \u2192 suggestion: ${link4.suggestion}`, fr: ` \u2192 suggestion : ${link4.suggestion}` });
+  }
+  const detail = link4.detail !== void 0 ? ` \u2014 ${link4.detail}` : "";
+  if (link4.reason === "anchor") {
+    return pick3(locale, { en: ` (heading/anchor not found${detail})`, fr: ` (ancre introuvable${detail})` });
+  }
+  if (link4.reason === "line") {
+    return pick3(locale, { en: ` (line number out of range${detail})`, fr: ` (num\xE9ro de ligne hors limites${detail})` });
+  }
+  return pick3(locale, { en: " (no unique target)", fr: " (aucune cible unique)" });
+};
+var resolvePendingCheck = ({ base: base2, existsCache, contentCache, anchorCache, dfs, index: index2, item, known }) => Effect_exports.gen(function* () {
+  let exists2 = existsCache.get(item.targetAbs);
+  if (exists2 === void 0) {
+    if (known.has(item.targetAbs)) {
+      exists2 = true;
+    } else if (isWithinBase(item.targetAbs, base2)) {
+      exists2 = yield* dfs.exists(item.targetAbs);
+    } else {
+      exists2 = false;
+    }
+    existsCache.set(item.targetAbs, exists2);
+  }
+  if (!exists2) {
+    const suggestion = suggestFix({ fromDir: item.fromDir, index: index2, target: item.target });
+    return suggestion ? { reason: "path", suggestion, target: item.target, text: item.text } : { reason: "path", target: item.target, text: item.text };
+  }
+  if (item.anchor === null) {
+    return null;
+  }
+  let content = contentCache.get(item.targetAbs);
+  if (content === void 0) {
+    content = yield* dfs.readFile(item.targetAbs).pipe(Effect_exports.catchDefect(() => Effect_exports.succeed(null)));
+    contentCache.set(item.targetAbs, content);
+  }
+  if (content === null) {
+    return null;
+  }
+  const normalized = normalizeAnchor(item.anchor);
+  const lineRange = parseLineAnchor(normalized);
+  if (lineRange) {
+    const lineCount = content.split("\n").length;
+    if (isValidLineAnchor(lineRange, lineCount)) {
+      return null;
+    }
+    const detail = `target has ${lineCount} line${lineCount === 1 ? "" : "s"}`;
+    return { detail, reason: "line", target: item.target, text: item.text };
+  }
+  if (!item.targetAbs.toLowerCase().endsWith(".md")) {
+    return null;
+  }
+  let anchors = anchorCache.get(item.targetAbs);
+  if (!anchors) {
+    anchors = extractAnchors(content);
+    anchorCache.set(item.targetAbs, anchors);
+  }
+  return anchors.has(normalized) ? null : { detail: describeAnchors(anchors), reason: "anchor", target: item.target, text: item.text };
+});
+var checkLinks = ({ base: base2, fix, ignore: ignore4 = [], roots }) => Effect_exports.gen(function* () {
   const dfs = yield* DocsFs;
   const allFiles = yield* dfs.listFiles(roots);
   const index2 = buildBasenameIndex(allFiles);
   const known = withAncestors(allFiles);
   const existsAbs = (p) => known.has(p);
+  const inRoots = (p) => roots.some((root) => p === root || p.startsWith(`${root}/`));
   const mdFiles = allFiles.filter((file4) => file4.endsWith(".md") && !matchesAny(file4, ignore4));
+  const scans = [];
+  for (const file4 of mdFiles) {
+    const content = yield* dfs.readFile(file4);
+    const { broken: syncBroken, pending } = checkContent({ content, existsAbs, fileAbs: file4, inRoots, index: index2 });
+    scans.push({ content, file: file4, pending, resolvedExtra: [], syncBroken });
+  }
+  const existsCache = /* @__PURE__ */ new Map();
+  const contentCache = /* @__PURE__ */ new Map();
+  const anchorCache = /* @__PURE__ */ new Map();
+  for (const scan of scans) {
+    for (const item of scan.pending) {
+      const result3 = yield* resolvePendingCheck({
+        anchorCache,
+        base: base2,
+        contentCache,
+        dfs,
+        existsCache,
+        index: index2,
+        item,
+        known
+      });
+      if (result3) {
+        scan.resolvedExtra.push(result3);
+      }
+    }
+  }
   const broken = [];
   let fixed = 0;
-  for (const file4 of mdFiles) {
-    let content = yield* dfs.readFile(file4);
-    const links = checkContent({ content, existsAbs, fileAbs: file4, index: index2 });
+  for (const scan of scans) {
+    let content = scan.content;
+    const links = [...scan.syncBroken, ...scan.resolvedExtra];
     if (links.length === 0) {
       continue;
     }
@@ -75298,18 +75627,195 @@ var checkLinks = ({ fix, ignore: ignore4 = [], roots }) => Effect_exports.gen(fu
       }
     }
     if (changed) {
-      yield* dfs.writeFile(file4, content);
+      yield* dfs.writeFile(scan.file, content);
     }
     if (remaining.length > 0) {
-      broken.push({ file: file4, links: remaining });
+      broken.push({ file: scan.file, links: remaining });
     }
   }
   return { broken, checked: mdFiles.length, fixed };
 });
 
-// dist/core/SummaryTree.js
-import * as nodePath3 from "node:path";
-var path9 = nodePath3.posix;
+// dist/program/links/CheckRefs.js
+import * as nodePath5 from "node:path";
+
+// dist/core/sidecar.js
+import * as nodePath4 from "node:path";
+var path10 = nodePath4.posix;
+var META_DIR = ".cairn";
+var metaRootFor = (base2) => path10.join(base2, META_DIR);
+var isSidecarPath = (candidate, metaRoot) => candidate === metaRoot || candidate.startsWith(`${metaRoot}/`);
+var sidecarPathFor = (nodeAtPath, layout, namespace) => {
+  const rel = path10.relative(layout.base, nodeAtPath);
+  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
+    throw new Error(`sidecarPathFor: "${nodeAtPath}" is not under base "${layout.base}"`);
+  }
+  const root = namespace === void 0 ? layout.metaRoot : path10.join(layout.metaRoot, namespace);
+  return `${path10.join(root, rel)}.json`;
+};
+var nodePathForSidecar = (sidecarPath, layout) => {
+  if (!isSidecarPath(sidecarPath, layout.metaRoot) || !sidecarPath.endsWith(".json")) {
+    return null;
+  }
+  const rel = path10.relative(layout.metaRoot, sidecarPath);
+  if (rel.startsWith("..")) {
+    return null;
+  }
+  return path10.join(layout.base, rel.slice(0, -".json".length));
+};
+var makeSidecarCodec = (schema) => {
+  const decode2 = Schema_exports.decodeUnknownResult(schema);
+  return {
+    parse: (content) => {
+      let json2;
+      try {
+        json2 = JSON.parse(content);
+      } catch {
+        return null;
+      }
+      const decoded = decode2(json2);
+      return Result_exports.isSuccess(decoded) ? decoded.success : null;
+    },
+    serialize: (record3) => `${JSON.stringify(record3, null, 2)}
+`
+  };
+};
+
+// dist/core/links/RefStore.js
+var REFS_DIR = "refs";
+var RefRecordSchema = Schema_exports.Struct({
+  anchor: Schema_exports.optionalKey(Schema_exports.String),
+  hash: Schema_exports.String,
+  target: Schema_exports.String
+});
+var RefsRecordSchema = Schema_exports.Struct({
+  refs: Schema_exports.Array(RefRecordSchema)
+});
+var refsCodec = makeSidecarCodec(RefsRecordSchema);
+var serializeRefs = refsCodec.serialize;
+var parseRefs = refsCodec.parse;
+var refsSidecarPathFor = (docAtPath, layout) => sidecarPathFor(docAtPath, layout, REFS_DIR);
+
+// dist/core/hashing.js
+import { hash as hashHex } from "node:crypto";
+var hashContent = (content) => hashHex("sha256", content, "hex");
+
+// dist/program/links/CheckRefs.js
+var path11 = nodePath5.posix;
+var refsExitCode = (result3) => result3.stale.length > 0 ? 1 : 0;
+var resolveReferenceContent = ({ base: base2, dfs, targetAbs }) => Effect_exports.gen(function* () {
+  if (!isWithinBase(targetAbs, base2)) {
+    return null;
+  }
+  const exists2 = yield* dfs.exists(targetAbs);
+  if (!exists2) {
+    return null;
+  }
+  return yield* dfs.readFile(targetAbs).pipe(Effect_exports.catchDefect(() => Effect_exports.succeed(null)));
+});
+var listMdFiles = (roots) => Effect_exports.gen(function* () {
+  const dfs = yield* DocsFs;
+  const allFiles = yield* dfs.listFiles(roots);
+  return allFiles.filter((f) => f.endsWith(".md"));
+});
+var toRecord = (ref, hash3) => ref.anchor === null ? { hash: hash3, target: ref.target } : { anchor: ref.anchor, hash: hash3, target: ref.target };
+var stampRefs = ({ base: base2, roots }) => Effect_exports.gen(function* () {
+  const dfs = yield* DocsFs;
+  const layout = { base: base2, metaRoot: metaRootFor(base2) };
+  const mdFiles = yield* listMdFiles(roots);
+  let stamped = 0;
+  for (const file4 of mdFiles) {
+    const content = yield* dfs.readFile(file4);
+    const fromDir = path11.dirname(file4);
+    const records = [];
+    for (const ref of extractReferences(content)) {
+      const targetAbs = path11.resolve(fromDir, ref.target);
+      const targetContent = yield* resolveReferenceContent({ base: base2, dfs, targetAbs });
+      if (targetContent !== null) {
+        records.push(toRecord(ref, hashContent(targetContent)));
+      }
+    }
+    if (records.length > 0) {
+      yield* dfs.writeFile(refsSidecarPathFor(file4, layout), serializeRefs({ refs: records }));
+      stamped += 1;
+    }
+  }
+  return { stamped };
+});
+var checkRefs = ({ base: base2, roots }) => Effect_exports.gen(function* () {
+  const dfs = yield* DocsFs;
+  const layout = { base: base2, metaRoot: metaRootFor(base2) };
+  const mdFiles = yield* listMdFiles(roots);
+  const stale = [];
+  let checked = 0;
+  for (const file4 of mdFiles) {
+    const sidecarPath = refsSidecarPathFor(file4, layout);
+    const sidecarExists = yield* dfs.exists(sidecarPath);
+    if (!sidecarExists) {
+      continue;
+    }
+    const recorded = parseRefs(yield* dfs.readFile(sidecarPath));
+    if (recorded === null) {
+      continue;
+    }
+    checked += 1;
+    const fromDir = path11.dirname(file4);
+    const drifted = [];
+    for (const record3 of recorded.refs) {
+      const targetAbs = path11.resolve(fromDir, record3.target);
+      const targetContent = yield* resolveReferenceContent({ base: base2, dfs, targetAbs });
+      if (targetContent === null) {
+        continue;
+      }
+      const currentHash = hashContent(targetContent);
+      if (currentHash !== record3.hash) {
+        drifted.push(record3.anchor === void 0 ? { currentHash, recordedHash: record3.hash, target: record3.target } : { anchor: record3.anchor, currentHash, recordedHash: record3.hash, target: record3.target });
+      }
+    }
+    if (drifted.length > 0) {
+      stale.push({ file: file4, refs: drifted });
+    }
+  }
+  return { checked, stale };
+});
+var formatRefsReport = (result3, options = {}) => {
+  const locale = options.locale ?? "en";
+  const lines2 = [];
+  if (result3.stale.length === 0) {
+    lines2.push(pick3(locale, {
+      en: `\u2705 References OK (${result3.checked} tracked doc(s)).`,
+      fr: `\u2705 R\xE9f\xE9rences OK (${result3.checked} document(s) suivi(s)).`
+    }));
+    return lines2;
+  }
+  const total = result3.stale.reduce((n, f) => n + f.refs.length, 0);
+  lines2.push(pick3(locale, {
+    en: `\u26A0\uFE0F  ${total} possibly stale reference(s):`,
+    fr: `\u26A0\uFE0F  ${total} r\xE9f\xE9rence(s) possiblement obsol\xE8te(s) :`
+  }));
+  for (const { file: file4, refs } of result3.stale) {
+    lines2.push(`  ${file4}`);
+    for (const ref of refs) {
+      const anchorSuffix = ref.anchor !== void 0 ? `#${ref.anchor}` : "";
+      lines2.push(`    ~ ${ref.target}${anchorSuffix} (${ref.recordedHash.slice(0, 8)} \u2192 ${ref.currentHash.slice(0, 8)})`);
+    }
+  }
+  return lines2;
+};
+
+// dist/core/summaries/StampStore.js
+var STAMP_VERSION = 1;
+var StampRecordSchema = Schema_exports.Struct({
+  sha256: Schema_exports.String,
+  version: Schema_exports.Number
+});
+var stampCodec = makeSidecarCodec(StampRecordSchema);
+var serializeStamp = stampCodec.serialize;
+var parseStamp = stampCodec.parse;
+
+// dist/core/summaries/SummaryTree.js
+import * as nodePath6 from "node:path";
+var path12 = nodePath6.posix;
 var DIR_SUMMARY = DEFAULT_NAMING.dirSummary;
 var EMPTY_STAMPS = /* @__PURE__ */ new Map();
 var DEFAULT_THRESHOLD_LINES2 = 30;
@@ -75322,7 +75828,7 @@ var resolveLinks = (content, dir2) => {
     }
     const rel = stripAnchor(target);
     if (rel) {
-      set4.add(path9.resolve(dir2, rel));
+      set4.add(path12.resolve(dir2, rel));
     }
   }
   return set4;
@@ -75340,8 +75846,8 @@ var nodeExpectedHash = ({ files, inputs, kind, path: nodeAtPath }) => {
   if (kind === "file") {
     return hashContent(files.get(inputs[0] ?? "") ?? "");
   }
-  const dir2 = path9.dirname(nodeAtPath);
-  const manifest = inputs.map((input) => `${path9.relative(dir2, input)}:${hashContent(files.get(input) ?? "")}`).toSorted().join("\n");
+  const dir2 = path12.dirname(nodeAtPath);
+  const manifest = inputs.map((input) => `${path12.relative(dir2, input)}:${hashContent(files.get(input) ?? "")}`).toSorted().join("\n");
   return hashContent(manifest);
 };
 var planSummaries = ({ files, ignore: ignore4 = [], naming = DEFAULT_NAMING, requireDirSummaries = true, roots, stamps = EMPTY_STAMPS, thresholdLines = DEFAULT_THRESHOLD_LINES2 }) => {
@@ -75380,10 +75886,10 @@ var planSummaries = ({ files, ignore: ignore4 = [], naming = DEFAULT_NAMING, req
   const inScope = (d) => roots.some((r) => d === r || d.startsWith(`${r}/`));
   const dirs = /* @__PURE__ */ new Set();
   for (const doc of sourceDocs) {
-    let d = path9.dirname(doc);
+    let d = path12.dirname(doc);
     while (inScope(d)) {
       dirs.add(d);
-      const parent = path9.dirname(d);
+      const parent = path12.dirname(d);
       if (parent === d) {
         break;
       }
@@ -75392,7 +75898,7 @@ var planSummaries = ({ files, ignore: ignore4 = [], naming = DEFAULT_NAMING, req
   }
   const docsByParent = /* @__PURE__ */ new Map();
   for (const doc of sourceDocs) {
-    const parent = path9.dirname(doc);
+    const parent = path12.dirname(doc);
     const bucket = docsByParent.get(parent);
     if (bucket) {
       bucket.push(doc);
@@ -75402,7 +75908,7 @@ var planSummaries = ({ files, ignore: ignore4 = [], naming = DEFAULT_NAMING, req
   }
   const dirsByParent = /* @__PURE__ */ new Map();
   for (const d of dirs) {
-    const parent = path9.dirname(d);
+    const parent = path12.dirname(d);
     const bucket = dirsByParent.get(parent);
     if (bucket) {
       bucket.push(d);
@@ -75416,9 +75922,9 @@ var planSummaries = ({ files, ignore: ignore4 = [], naming = DEFAULT_NAMING, req
     const childDirs = dirsByParent.get(dir2) ?? [];
     const inputs = [
       ...childDocs.map((doc) => isBig(doc) ? summaryPathFor(doc, naming) : doc),
-      ...childDirs.map((sub) => path9.join(sub, naming.dirSummary))
+      ...childDirs.map((sub) => path12.join(sub, naming.dirSummary))
     ];
-    const dsp = path9.join(dir2, naming.dirSummary);
+    const dsp = path12.join(dir2, naming.dirSummary);
     const expectedHash = nodeExpectedHash({ files, inputs, kind: "dir", path: dsp });
     const recordedHash = recorded(dsp);
     const exists2 = files.has(dsp);
@@ -75455,49 +75961,7 @@ var findOrphans = ({ files, ignore: ignore4, naming, nodes, requireDirSummaries
 };
 var isManagedSummaryPath = (p, naming, requireDirSummaries) => isSummaryFile(p, naming) || requireDirSummaries && isDirSummary(p, naming);
 
-// dist/core/StampStore.js
-import * as nodePath4 from "node:path";
-var path10 = nodePath4.posix;
-var META_DIR = ".cairn";
-var STAMP_VERSION = 1;
-var StampRecordSchema = Schema_exports.Struct({
-  sha256: Schema_exports.String,
-  version: Schema_exports.Number
-});
-var decodeStamp = Schema_exports.decodeUnknownResult(StampRecordSchema);
-var serializeStamp = (record3) => `${JSON.stringify(record3, null, 2)}
-`;
-var parseStamp = (content) => {
-  let json2;
-  try {
-    json2 = JSON.parse(content);
-  } catch {
-    return null;
-  }
-  const decoded = decodeStamp(json2);
-  return Result_exports.isSuccess(decoded) ? decoded.success : null;
-};
-var metaRootFor = (base2) => path10.join(base2, META_DIR);
-var isSidecarPath = (candidate, metaRoot) => candidate === metaRoot || candidate.startsWith(`${metaRoot}/`);
-var sidecarPathFor = (nodeAtPath, layout) => {
-  const rel = path10.relative(layout.base, nodeAtPath);
-  if (rel.startsWith("..") || path10.isAbsolute(rel)) {
-    throw new Error(`sidecarPathFor: "${nodeAtPath}" is not under base "${layout.base}"`);
-  }
-  return `${path10.join(layout.metaRoot, rel)}.json`;
-};
-var nodePathForSidecar = (sidecarPath, layout) => {
-  if (!isSidecarPath(sidecarPath, layout.metaRoot) || !sidecarPath.endsWith(".json")) {
-    return null;
-  }
-  const rel = path10.relative(layout.metaRoot, sidecarPath);
-  if (rel.startsWith("..")) {
-    return null;
-  }
-  return path10.join(layout.base, rel.slice(0, -".json".length));
-};
-
-// dist/program/CheckSummaries.js
+// dist/program/summaries/CheckSummaries.js
 var EMPTY_STAMPS2 = /* @__PURE__ */ new Map();
 var layoutFor = (base2) => ({ base: base2, metaRoot: metaRootFor(base2) });
 var toPlanArgs = (files, args2, stamps = EMPTY_STAMPS2) => ({
@@ -75718,6 +76182,7 @@ var explainOption = Flag_exports.boolean("explain").pipe(Flag_exports.withDescri
 var jsonOption = Flag_exports.boolean("json").pipe(Flag_exports.withDescription("Machine-readable combined report: { summaries, links, exitCode }."));
 var linksOnlyOption = Flag_exports.boolean("links-only").pipe(Flag_exports.withDescription("Check only Markdown links."));
 var summariesOnlyOption = Flag_exports.boolean("summaries-only").pipe(Flag_exports.withDescription("Check only summary freshness."));
+var refsOption = Flag_exports.boolean("refs").pipe(Flag_exports.withDescription(`Opt-in (issue #39 Scenario I, v1/whole-file): with --stamp, record each doc's real reference targets' content hashes into .cairn/**; without --stamp, report any whose target content has drifted since \u2014 "may be stale," distinct from a broken link.`));
 var configPathOption = Flag_exports.string("config").pipe(Flag_exports.withDescription("Path to a config file (default: .cairnrc.json / .cairnrc / package.json#cairn)."), Flag_exports.optional);
 var thresholdOption = Flag_exports.integer("threshold").pipe(Flag_exports.withDescription("Line count above which a file needs a summary (overrides config)."), Flag_exports.optional);
 var localeOption = Flag_exports.choice("locale", LOCALES).pipe(Flag_exports.withDescription("Report language (overrides config)."), Flag_exports.optional);
@@ -75742,6 +76207,11 @@ var runCheck = Effect_exports.fn("runCheck")(function* (parsed) {
     yield* Effect_exports.sync(() => process.exitCode = 1);
     return;
   }
+  if (parsed.json && parsed.refs) {
+    yield* Console_exports.log(JSON.stringify({ error: "--json cannot be combined with --refs yet" }));
+    yield* Effect_exports.sync(() => process.exitCode = 1);
+    return;
+  }
   const absRoots = expandRoots(cwd, config.roots);
   const summaryArgs = {
     base: cwd,
@@ -75761,7 +76231,7 @@ var runCheck = Effect_exports.fn("runCheck")(function* (parsed) {
     }));
   }
   if (config.checks.links && !parsed.summariesOnly) {
-    const links = yield* checkLinks({ fix: parsed.fix, ignore: config.ignore, roots: absRoots });
+    const links = yield* checkLinks({ base: cwd, fix: parsed.fix, ignore: config.ignore, roots: absRoots });
     linksResult = links;
     if (!parsed.json) {
       yield* Console_exports.log(formatLinkReport(links, { locale }).join("\n"));
@@ -75819,6 +76289,20 @@ var runCheck = Effect_exports.fn("runCheck")(function* (parsed) {
       code = Math.max(code, summaryExitCode(summaries));
     }
   }
+  if (parsed.refs) {
+    const refsArgs = { base: cwd, roots: absRoots };
+    if (parsed.stamp) {
+      const result3 = yield* stampRefs(refsArgs);
+      yield* Console_exports.log(pick3(locale, {
+        en: `\u{1F517} Stamped ${result3.stamped} doc(s)' reference hash(es) (.cairn/** sidecar).`,
+        fr: `\u{1F517} ${result3.stamped} document(s) tamponn\xE9(s) (hachage des r\xE9f\xE9rences, fichier annexe .cairn/**).`
+      }));
+    } else {
+      const result3 = yield* checkRefs(refsArgs);
+      yield* Console_exports.log(formatRefsReport(result3, { locale }).join("\n"));
+      code = Math.max(code, refsExitCode(result3));
+    }
+  }
   if (parsed.json) {
     const report = buildJsonReport({ links: linksResult, summaries: summariesResult });
     yield* Console_exports.log(JSON.stringify(report, null, 2));
@@ -75837,6 +76321,7 @@ var checkConfigShape = {
   locale: localeOption,
   migrateStamps: migrateStampsOption,
   prune: pruneOption,
+  refs: refsOption,
   root: rootOption,
   roots: rootsArgs,
   stamp: stampOption,
@@ -75872,7 +76357,7 @@ var runConfigCommand = Effect_exports.fn("runConfig")(function* ({ config: confi
 });
 var configCommand = Command_exports.make("config", { config: configPathOption, locale: localeOption, path: configPathArg, root: rootOption, threshold: thresholdOption }, runConfigCommand).pipe(Command_exports.withDescription(`Print the resolved config, which file it came from, and expanded roots (debug "why aren't my docs checked").`));
 var cairn = Command_exports.make("cairn", checkConfigShape, runCheck).pipe(Command_exports.withSubcommands([checkCommand, initCommand, configCommand]));
-var packageJsonPath = path11.join(import.meta.dirname, "..", "package.json");
+var packageJsonPath = path13.join(import.meta.dirname, "..", "package.json");
 var { version: version2 } = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
 cairn.pipe(Command_exports.run({ version: version2 }), Effect_exports.tapErrorTag("CairnConfigError", (error2) => Console_exports.error(error2.message)), Effect_exports.provide(DocsFsLive), Effect_exports.provide(NodeServices_exports.layer), NodeRuntime_exports.runMain);
 /*! Bundled license information: