canopycms 0.0.62 → 0.0.64

package/dist/ai/to-plain-text.js

@@ -0,0 +1,301 @@
+/**
+ * Convert MDX/Markdown body content to plain prose text, suitable for a
+ * search index or any other consumer that wants "just the words".
+ *
+ * This is deliberately a *different* transform from `stripMdxImports`
+ * (strip-mdx.ts): that one is tuned for AI/RAG consumption and intentionally
+ * leaves JSX components intact, because their props often carry semantic
+ * data a model can use. `toPlainText` has the opposite goal — it removes ALL
+ * markup (JSX tags, JSX expressions, markdown syntax) and keeps only the
+ * prose, so **paired custom components lose their tags but keep their
+ * children's text**. That distinction is the whole reason this function
+ * exists: a hand-rolled plaintext stripper that treats a paired component
+ * like `<Callout>...</Callout>` as one opaque unit and deletes it wholesale
+ * silently drops every word inside it from the search index. `toPlainText`
+ * strips the `<Callout>`/`</Callout>` delimiters but keeps the sentence
+ * between them.
+ *
+ * Pipeline (each step operates on the previous step's output):
+ * 1. Strip YAML frontmatter (via `gray-matter`, the same parser
+ *    `content-store.ts` uses for `.md`/`.mdx` bodies).
+ * 2. Strip `import`/`export` statements (via `stripMdxImports`), which also
+ *    protects fenced code blocks from every later step.
+ * 3. Mask fenced code blocks and inline code spans, capturing their content
+ *    (fence markers / backticks are discarded, the code text is kept).
+ * 4. Strip JSX/HTML tags — opening, closing, and self-closing — leaving
+ *    whatever text sits between them in place. This is a single global
+ *    replace, not a matched-pair walk: because we never need the tag name or
+ *    the children as a unit (unlike `applyComponentTransforms`, which calls
+ *    an adopter transform per component), deleting every tag occurrence and
+ *    leaving the surrounding text untouched handles nesting for free.
+ * 5. Strip JSX expressions (`{...}`, including nested braces) — these are
+ *    code, not prose.
+ * 6. Strip common Markdown syntax: headings, emphasis/strikethrough, links
+ *    (keep the link text, drop the URL), images (keep alt text), blockquote
+ *    markers, list markers, and thematic breaks.
+ * 7. Restore the masked code from step 3 as plain text.
+ * 8. Collapse whitespace: trim each line, collapse runs of blank lines,
+ *    trim the result. Paragraph breaks (single blank lines) are preserved —
+ *    this does not flatten the output to one line.
+ */
+import matter from 'gray-matter';
+import { stripMdxImports } from './strip-mdx.js';
+/**
+ * Masking markers use `@` right after `<` (and before the closing `>`),
+ * e.g. `<@B0@>`. `@` is not a valid JSX tag-name start (`[A-Za-z]` only), so
+ * TAG_RE below can never mistake the marker for a real tag — unlike
+ * transform-components.ts's `<<CODEBLOCK0>>` convention, which is safe
+ * there only because that module never runs a *generic* tag-stripping regex
+ * over its masked text (this one does: `<CODEBLOCK0>` inside `<<...>>`
+ * reads as a valid tag name to a naive tag matcher, which is exactly the
+ * bug this format avoids). `@` also doesn't participate in any of the
+ * Markdown-syntax regexes below, so a marker surviving to that stage is
+ * inert there too.
+ */
+const BLOCK_PREFIX = '<@B';
+const BLOCK_SUFFIX = '@>';
+const BLOCK_RESTORE_RE = /<@B(\d+)@>/g;
+const INLINE_PREFIX = '<@I';
+const INLINE_SUFFIX = '@>';
+const INLINE_RESTORE_RE = /<@I(\d+)@>/g;
+/** JSX attribute content: skips quoted strings so a `>` inside `title="a > b"` doesn't end the tag early. */
+const ATTR_CONTENT = `(?:[^<>"']|"[^"]*"|'[^']*')*`;
+/**
+ * Matches an opening, closing, or self-closing JSX/HTML tag, or a fragment (`<>`/`</>`).
+ *
+ * No trailing `\s*` before the final `\/?>`: `ATTR_CONTENT`'s `[^<>"']` alternative already
+ * matches whitespace, so a trailing `\s*` on top of it lets the engine split any whitespace run
+ * between the two in every possible proportion. On an unterminated tag (no closing `>` in the
+ * input) followed by a long whitespace run, that ambiguity is polynomial-ReDoS shaped (CodeQL
+ * `js/polynomial-redos`): matching cost is quadratic in the run length before the engine gives up
+ * and backtracks to try the next start position. Measured on a 128 KB whitespace tail: ~26s with
+ * the redundant `\s*`, ~1ms without it. `ATTR_CONTENT` already absorbs the trailing whitespace on
+ * its own, so removing the `\s*` changes no matched output.
+ */
+const TAG_RE = new RegExp(`<\\/?([A-Za-z][\\w.-]*)?(?:\\s${ATTR_CONTENT})?\\/?>`, 'g');
+const COMMENT_OPEN = '<!--';
+const COMMENT_CLOSE = '-->';
+/**
+ * Strip well-formed HTML/MDX comments (`<!-- ... -->`), including their contents.
+ *
+ * `TAG_RE` cannot do this: its tag-name group is `[A-Za-z]`-initial, so `<!--` matches neither
+ * the name nor the bare-fragment form, and both delimiters plus every word between them survive
+ * into the extracted text. Authoring notes then show up verbatim in a search index or an AI
+ * export — text the author explicitly marked as not-for-readers.
+ *
+ * A hand-rolled `indexOf` scan rather than `/<!--[\s\S]*?-->/g`, for the same reason
+ * `maskFencedCodeBlocks` above is hand-rolled: that lazy pattern has no bound on how far it
+ * scans looking for a closer, so on input with many unterminated `<!--` openers the engine
+ * exhausts to end-of-string at every one of them — quadratic in the number of openers, the same
+ * polynomial-ReDoS shape documented on `TAG_RE` and the fence scanner. This scan visits each
+ * character at most once.
+ *
+ * An UNTERMINATED `<!--` is deliberately left alone rather than swallowing the rest of the
+ * document. HTML would run such a comment to EOF, but here the input is prose being extracted
+ * for search and AI consumption, where silently dropping everything after a mistyped delimiter
+ * loses far more than it protects. The stray `<!--` survives as literal text, which is visible
+ * and fixable; a vanished second half of a document is neither.
+ *
+ * Runs while fenced/inline code is still masked, so a comment shown as example code keeps its
+ * delimiters.
+ */
+function stripHtmlComments(text) {
+    let searchFrom = 0;
+    let open = text.indexOf(COMMENT_OPEN, searchFrom);
+    if (open === -1)
+        return text;
+    let out = '';
+    while (open !== -1) {
+        const close = text.indexOf(COMMENT_CLOSE, open + COMMENT_OPEN.length);
+        if (close === -1)
+            break;
+        out += text.slice(searchFrom, open) + ' ';
+        searchFrom = close + COMMENT_CLOSE.length;
+        open = text.indexOf(COMMENT_OPEN, searchFrom);
+    }
+    return out + text.slice(searchFrom);
+}
+/** True if `line` is a valid closing fence line for `marker` ("```" or "~~~"): the marker
+ * followed by nothing but whitespace through end of line — matching what `\1\s*$` required in
+ * the regex this replaced. */
+function isFenceCloseLine(line, marker) {
+    return line.startsWith(marker) && /^\s*$/.test(line.slice(marker.length));
+}
+/**
+ * Mask fenced code blocks (` ``` `/`~~~`), capturing each block's *content* so `restore`
+ * re-inserts plain text — no fence markers, no language tag.
+ *
+ * A hand-rolled line scan, not `/^(```|~~~).*\n([\s\S]*?)\n\1\s*$/gm`: that regex is a second
+ * polynomial-ReDoS shape (measured ~9s on ~530KB of body text with many unclosed fence openers,
+ * a plausible authoring accident — the same trigger class as `TAG_RE` above, in the same
+ * function). The lazy `[\s\S]*?` has no bound on how far it must scan looking for a closing
+ * `\1` that, for an unclosed fence, never arrives — it exhausts to the end of the string before
+ * giving up on that starting line, and `/gm` retries the same exhaustive scan at every
+ * subsequent fence-opener line, which is quadratic in the number of unclosed openers.
+ *
+ * This scans each line once. `nextCloseLine` is precomputed per marker type via a single
+ * backward pass, so any opener's nearest closer (or "none exists") is an O(1) lookup rather than
+ * a fresh forward scan — the change that makes the whole function O(n) regardless of how many
+ * fences are opened and never closed.
+ */
+function maskFencedCodeBlocks(body, blocks) {
+    const lines = body.split('\n');
+    const lineCount = lines.length;
+    // nextCloseLine[marker][i] = the nearest index >= i that closes `marker`, or -1 if none exists
+    // at or after i. Built right-to-left so each entry is O(1) given the next one.
+    const nextCloseLine = {
+        '```': new Array(lineCount + 1).fill(-1),
+        '~~~': new Array(lineCount + 1).fill(-1),
+    };
+    for (let i = lineCount - 1; i >= 0; i--) {
+        nextCloseLine['```'][i] = isFenceCloseLine(lines[i], '```') ? i : nextCloseLine['```'][i + 1];
+        nextCloseLine['~~~'][i] = isFenceCloseLine(lines[i], '~~~') ? i : nextCloseLine['~~~'][i + 1];
+    }
+    const outLines = [];
+    let i = 0;
+    while (i < lineCount) {
+        const line = lines[i];
+        const marker = line.startsWith('```') ? '```' : line.startsWith('~~~') ? '~~~' : null;
+        // A closer can never be the very next line: the original pattern requires TWO separate `\n`
+        // matches between the opener and `\1` (one ending the opener's line, one immediately before
+        // the closer), so even zero-width content needs a line of its own between them.
+        const searchFrom = i + 2;
+        const closeIndex = marker && searchFrom < lineCount ? nextCloseLine[marker][searchFrom] : -1;
+        if (!marker || closeIndex === -1) {
+            outLines.push(line);
+            i++;
+            continue;
+        }
+        const content = lines.slice(i + 1, closeIndex).join('\n');
+        const idx = blocks.length;
+        blocks.push(content);
+        // Matches the replaced regex's `\n${...}\n` callback wrapping: the placeholder becomes its
+        // own blank-line-delimited chunk. (Any resulting difference in surrounding blank-line COUNT
+        // is immaterial -- collapseWhitespace normalizes runs of 3+ newlines down to one blank line
+        // before this ever reaches a caller.)
+        outLines.push('', `${BLOCK_PREFIX}${idx}${BLOCK_SUFFIX}`, '');
+        i = closeIndex + 1;
+    }
+    return outLines.join('\n');
+}
+/**
+ * Mask fenced code blocks and inline code spans, capturing their *content*
+ * (not the raw fenced/backticked text) so `restore` re-inserts plain text —
+ * no fence markers, no language tag, no backticks.
+ */
+function maskCode(body) {
+    const blocks = [];
+    const inlines = [];
+    let masked = maskFencedCodeBlocks(body, blocks);
+    masked = masked.replace(/``(.+?)``|`([^`]+)`/g, (_match, double, single) => {
+        const idx = inlines.length;
+        inlines.push((double ?? single ?? '').trim());
+        return `${INLINE_PREFIX}${idx}${INLINE_SUFFIX}`;
+    });
+    return {
+        masked,
+        restore: (s) => {
+            s = s.replace(INLINE_RESTORE_RE, (_match, i) => inlines[Number(i)]);
+            s = s.replace(BLOCK_RESTORE_RE, (_match, i) => blocks[Number(i)]);
+            return s;
+        },
+    };
+}
+/**
+ * Remove balanced `{...}` groups (JSX expressions), including nested braces,
+ * in a single pass. Each removed top-level group collapses to one space so
+ * surrounding words don't merge.
+ */
+function stripBraceExpressions(text) {
+    let result = '';
+    let depth = 0;
+    for (const ch of text) {
+        if (ch === '{') {
+            if (depth === 0)
+                result += ' ';
+            depth++;
+            continue;
+        }
+        if (ch === '}') {
+            if (depth > 0)
+                depth--;
+            continue;
+        }
+        if (depth === 0)
+            result += ch;
+    }
+    return result;
+}
+/** Strip common Markdown syntax, keeping the human-readable text. */
+function stripMarkdownSyntax(text) {
+    return (text
+        // Headings: leading `#` markers
+        .replace(/^ {0,3}#{1,6}\s+/gm, '')
+        // Blockquotes: leading `>` markers (possibly nested). Each repetition
+        // of the outer `+` consumes a mandatory `>` first, so it can't loop on
+        // an empty match — linear, despite the nested-quantifier shape the
+        // linter's heuristic flags.
+        // eslint-disable-next-line security/detect-unsafe-regex
+        .replace(/^ {0,3}(?:>\s?)+/gm, '')
+        // Thematic breaks: a line of 3+ `-`, `*`, or `_` (optionally
+        // space-separated). The backreference (`\1`) pins every repetition to
+        // the same captured character, which the linter's heuristic doesn't
+        // model — same false-positive shape as above.
+        // eslint-disable-next-line security/detect-unsafe-regex
+        .replace(/^ {0,3}([-*_])(?:\s*\1){2,}\s*$/gm, '')
+        // List markers: bullet or ordered
+        .replace(/^(\s*)[-*+]\s+/gm, '$1')
+        .replace(/^(\s*)\d+[.)]\s+/gm, '$1')
+        // Images: keep alt text, drop the URL entirely
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+        // Links: keep the link text, drop the URL
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        // Strikethrough / bold / italic — longest markers first so `**` isn't
+        // consumed as two `*` matches
+        .replace(/~~([^~]+)~~/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/__([^_]+)__/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/\b_([^_]+)_\b/g, '$1'));
+}
+/** Trim each line, collapse runs of blank lines, and trim the whole result. Preserves paragraph breaks. */
+function collapseWhitespace(text) {
+    return text
+        .split('\n')
+        .map((line) => line.replace(/[ \t]+/g, ' ').trim())
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+/**
+ * Convert MDX/Markdown body content to plain prose text.
+ *
+ * See the module doc above for the full pipeline and why this exists as a
+ * distinct transform from `stripMdxImports`. In short: frontmatter, code
+ * fences, inline code, JSX tags/expressions, and Markdown syntax are all
+ * stripped down to their human-readable text — code content and link/image
+ * text are kept, everything else is discarded. Paired custom components
+ * lose only their tags; the prose between them survives.
+ *
+ * HTML/MDX comments (`<!-- ... -->`) are removed along with their contents:
+ * an authoring note is text the author marked as not-for-readers, so it does
+ * not belong in a search index or an AI export.
+ *
+ * Output preserves paragraph breaks (blank lines) but is not further
+ * chunked, weighted, or field-selected — composing that into a search
+ * document is left to the caller, since that logic is where adopter search
+ * indexes genuinely diverge (see docs/adopter-migration.md).
+ */
+export function toPlainText(markdown) {
+    const { content } = matter(markdown);
+    const withoutImports = stripMdxImports(content);
+    const { masked, restore } = maskCode(withoutImports);
+    let result = masked;
+    result = stripHtmlComments(result);
+    result = result.replace(TAG_RE, ' ');
+    result = stripBraceExpressions(result);
+    result = stripMarkdownSyntax(result);
+    result = restore(result);
+    result = collapseWhitespace(result);
+    return result;
+}

package/dist/ai/transform-components.d.ts

@@ -9,7 +9,7 @@
  * components, so nested components are handled naturally (inner first,
  * outer on subsequent passes).
  */
-import type { ComponentProps, ComponentTransforms } from './types';
+import type { ComponentProps, ComponentTransforms } from './types.js';
 /**
  * Parse JSX attribute string into a props object.
  *
@@ -24,4 +24,3 @@ export declare function parseComponentProps(attrString: string): ComponentProps;
  * handle nesting (inner components first, outer on subsequent passes).
  */
 export declare function applyComponentTransforms(body: string, transforms: ComponentTransforms): string;
-//# sourceMappingURL=transform-components.d.ts.map

package/dist/ai/transform-components.js

@@ -42,6 +42,75 @@ const BLOCK_RESTORE_RE = /<<CODEBLOCK(\d+)>>/g;
 const INLINE_PREFIX = '<<INLINECODE';
 const INLINE_SUFFIX = '>>';
 const INLINE_RESTORE_RE = /<<INLINECODE(\d+)>>/g;
+/** True if `line` is a valid closing fence line for `marker` ("```" or "~~~"): the marker
+ * followed by nothing but whitespace through end of line — matching what `\1\s*$` required in
+ * the regex this replaced. */
+function isFenceCloseLine(line, marker) {
+    return line.startsWith(marker) && /^\s*$/.test(line.slice(marker.length));
+}
+/**
+ * Mask fenced code blocks (` ``` `/`~~~`), capturing each block's raw text (fence lines
+ * included) exactly as `maskCodeBlocks` used to via `/^(```|~~~).*\n[\s\S]*?\n\1\s*$/gm`.
+ *
+ * A hand-rolled line scan, not that regex: it is a polynomial-ReDoS shape (measured ~9s on
+ * ~530KB of body text with many unclosed fence openers — an ordinary authoring accident, not a
+ * crafted payload) that CodeQL and three review rounds both missed elsewhere in this package
+ * (see `ai/to-plain-text.ts`'s identical fix). The lazy `[\s\S]*?` has no bound on how far it
+ * must scan looking for a closing `\1` that, for an unclosed fence, never arrives — it exhausts
+ * to the end of the string before giving up on that starting line, and `/gm` retries the same
+ * exhaustive scan at every subsequent fence-opener line.
+ *
+ * This scans each line once. `nextCloseLine` is precomputed per marker type via a single
+ * backward pass, so any opener's nearest closer (or "none exists") is an O(1) lookup instead of
+ * a fresh forward scan — the change that keeps the whole function O(n) regardless of how many
+ * fences are opened and never closed.
+ *
+ * One documented, harmless divergence from the replaced regex: `\s*` there is greedy over `\s`
+ * (which includes `\n`), so on a closer immediately followed by blank lines it could consume
+ * some of them into the match. This scan never does. Verified by fuzzing 8,000 random
+ * fence/marker combinations through this module's actual `applyComponentTransforms` pipeline:
+ * final output was byte-identical in 7,999/8,000 cases, and the one divergence was an extra
+ * blank line in a maximally adversarial nested-tag-plus-fence input, never a content change —
+ * `\s` is never itself matched by any component-tag pattern, so which side of a placeholder a
+ * run of blank lines lands on cannot affect what a transform sees or produces.
+ */
+function maskFencedCodeBlocks(body, blocks) {
+    const lines = body.split('\n');
+    const lineCount = lines.length;
+    // nextCloseLine[marker][i] = the nearest index >= i that closes `marker`, or -1 if none exists
+    // at or after i. Built right-to-left so each entry is O(1) given the next one.
+    const nextCloseLine = {
+        '```': new Array(lineCount + 1).fill(-1),
+        '~~~': new Array(lineCount + 1).fill(-1),
+    };
+    for (let i = lineCount - 1; i >= 0; i--) {
+        nextCloseLine['```'][i] = isFenceCloseLine(lines[i], '```') ? i : nextCloseLine['```'][i + 1];
+        nextCloseLine['~~~'][i] = isFenceCloseLine(lines[i], '~~~') ? i : nextCloseLine['~~~'][i + 1];
+    }
+    const outLines = [];
+    let i = 0;
+    while (i < lineCount) {
+        const line = lines[i];
+        const marker = line.startsWith('```') ? '```' : line.startsWith('~~~') ? '~~~' : null;
+        // A closer can never be the very next line: the original pattern requires TWO separate `\n`
+        // matches between the opener and `\1` (one ending the opener's line, one immediately before
+        // the closer), so even zero-width content needs a line of its own between them.
+        const searchFrom = i + 2;
+        const closeIndex = marker && searchFrom < lineCount ? nextCloseLine[marker][searchFrom] : -1;
+        if (!marker || closeIndex === -1) {
+            outLines.push(line);
+            i++;
+            continue;
+        }
+        // Whole matched span (fence lines included), matching the replaced regex's own capture.
+        const block = lines.slice(i, closeIndex + 1).join('\n');
+        const idx = blocks.length;
+        blocks.push(block);
+        outLines.push(`${BLOCK_PREFIX}${idx}${BLOCK_SUFFIX}`);
+        i = closeIndex + 1;
+    }
+    return outLines.join('\n');
+}
 /**
  * Mask fenced code blocks and inline code spans so component transforms
  * don't touch them. Returns the masked string and a restore function.
@@ -50,11 +119,7 @@ function maskCodeBlocks(body) {
     const blocks = [];
     const inlines = [];
     // 1. Mask fenced code blocks
-    let masked = body.replace(/^(```|~~~).*\n[\s\S]*?\n\1\s*$/gm, (block) => {
-        const idx = blocks.length;
-        blocks.push(block);
-        return `${BLOCK_PREFIX}${idx}${BLOCK_SUFFIX}`;
-    });
+    let masked = maskFencedCodeBlocks(body, blocks);
     // 2. Mask inline code spans (double-backtick first, then single-backtick)
     masked = masked.replace(/``[^`]+``|`[^`]+`/g, (span) => {
         const idx = inlines.length;
@@ -165,4 +230,3 @@ function findMatchingClose(body, startFrom, name, closeTag) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-//# sourceMappingURL=transform-components.js.map

package/dist/ai/types.d.ts

@@ -4,7 +4,7 @@
  * These types define the configuration for generating AI-consumable markdown
  * from CanopyCMS content, and the output manifest/metadata structures.
  */
-import type { FieldConfig } from '../config';
+import type { FieldConfig } from '../config/index.js';
 /**
  * Metadata about an entry, provided to filter/predicate functions.
  * Does not include the full data payload — use `where` predicates for
@@ -234,4 +234,3 @@ export interface AIEntry extends AIEntryMeta {
      */
     appendedSections?: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/ai/types.js

@@ -11,4 +11,3 @@
 export function defineAIContentConfig(config) {
     return config;
 }
-//# sourceMappingURL=types.js.map

package/dist/api/admin-branch-health.d.ts

@@ -10,9 +10,9 @@
  * (double-hold on purge, release-then-save ordering on repair).
  */
 import { z } from 'zod';
-import type { BranchAccessControl, BranchMetadata, BranchStatus } from '../types';
-import { type BranchHealthEntry } from '../branch-health';
-import type { ApiResponse } from './types';
+import type { BranchAccessControl, BranchMetadata, BranchStatus } from '../types.js';
+import { type BranchHealthEntry } from '../branch-health.js';
+import type { ApiResponse } from './types.js';
 export interface BranchHealthData {
     entries: BranchHealthEntry[];
     generatedAt: string;
@@ -73,22 +73,22 @@ export type BranchDirParams = z.infer<typeof branchDirParamsSchema>;
  * router/generate-client import.
  */
 export declare const ADMIN_BRANCH_HEALTH_ROUTES: {
-    readonly branchHealth: import("./route-builder").RouteDefinition<undefined, undefined, BranchHealthResponse>;
-    readonly purgeBranchDir: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly branchHealth: import("./route-builder.js").RouteDefinition<undefined, undefined, BranchHealthResponse>;
+    readonly purgeBranchDir: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         dirName: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     }, "strip", z.ZodTypeAny, {
         dirName: string;
     }, {
         dirName: string;
     }>, undefined, PurgeBranchDirResponse>;
-    readonly repairBranchDir: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly repairBranchDir: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         dirName: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     }, "strip", z.ZodTypeAny, {
         dirName: string;
     }, {
         dirName: string;
     }>, undefined, RepairBranchDirResponse>;
-    readonly repairContentDuplicates: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly repairContentDuplicates: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         dirName: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     }, "strip", z.ZodTypeAny, {
         dirName: string;
@@ -97,4 +97,3 @@ export declare const ADMIN_BRANCH_HEALTH_ROUTES: {
     }>, undefined, RepairContentDuplicatesResponse>;
 };
 export {};
-//# sourceMappingURL=admin-branch-health.d.ts.map

package/dist/api/admin-branch-health.js

@@ -619,4 +619,3 @@ export const ADMIN_BRANCH_HEALTH_ROUTES = {
     repairBranchDir,
     repairContentDuplicates,
 };
-//# sourceMappingURL=admin-branch-health.js.map

package/dist/api/admin.d.ts

@@ -6,11 +6,11 @@
  * admin-branch-health.ts and are merged into ADMIN_ROUTES below.
  */
 import { z } from 'zod';
-import type { ApiResponse } from './types';
-import type { Task, QueueStats, CorruptTaskFile } from '../worker/task-queue';
-import type { WorkerStatusReport } from '../types';
-import type { OperatingMode } from '../operating-mode';
-export type { BranchHealthResponse, PurgeBranchDirResponse, RepairBranchDirResponse, RepairContentDuplicatesResponse, } from './admin-branch-health';
+import type { ApiResponse } from './types.js';
+import type { Task, QueueStats, CorruptTaskFile } from '../worker/task-queue.js';
+import type { WorkerStatusReport } from '../types.js';
+import type { OperatingMode } from '../operating-mode/index.js';
+export type { BranchHealthResponse, PurgeBranchDirResponse, RepairBranchDirResponse, RepairContentDuplicatesResponse, } from './admin-branch-health.js';
 export type WorkerLivenessState = 'alive' | 'stale' | 'absent';
 export interface WorkerLiveness {
     /**
@@ -89,30 +89,30 @@ export type DeleteTaskParams = z.infer<typeof deleteTaskParamsSchema>;
  * `ADMIN_ROUTES` import.
  */
 export declare const ADMIN_ROUTES: {
-    readonly branchHealth: import("./route-builder").RouteDefinition<undefined, undefined, import("./admin-branch-health").BranchHealthResponse>;
-    readonly purgeBranchDir: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly branchHealth: import("./route-builder.js").RouteDefinition<undefined, undefined, import("./admin-branch-health.js").BranchHealthResponse>;
+    readonly purgeBranchDir: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         dirName: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     }, "strip", z.ZodTypeAny, {
         dirName: string;
     }, {
         dirName: string;
-    }>, undefined, import("./admin-branch-health").PurgeBranchDirResponse>;
-    readonly repairBranchDir: import("./route-builder").RouteDefinition<z.ZodObject<{
+    }>, undefined, import("./admin-branch-health.js").PurgeBranchDirResponse>;
+    readonly repairBranchDir: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         dirName: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     }, "strip", z.ZodTypeAny, {
         dirName: string;
     }, {
         dirName: string;
-    }>, undefined, import("./admin-branch-health").RepairBranchDirResponse>;
-    readonly repairContentDuplicates: import("./route-builder").RouteDefinition<z.ZodObject<{
+    }>, undefined, import("./admin-branch-health.js").RepairBranchDirResponse>;
+    readonly repairContentDuplicates: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         dirName: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     }, "strip", z.ZodTypeAny, {
         dirName: string;
     }, {
         dirName: string;
-    }>, undefined, import("./admin-branch-health").RepairContentDuplicatesResponse>;
-    readonly status: import("./route-builder").RouteDefinition<undefined, undefined, AdminStatusResponse>;
-    readonly listTasks: import("./route-builder").RouteDefinition<z.ZodObject<{
+    }>, undefined, import("./admin-branch-health.js").RepairContentDuplicatesResponse>;
+    readonly status: import("./route-builder.js").RouteDefinition<undefined, undefined, AdminStatusResponse>;
+    readonly listTasks: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         status: z.ZodEnum<["pending", "processing", "completed", "failed", "corrupt"]>;
         limit: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
@@ -122,14 +122,14 @@ export declare const ADMIN_ROUTES: {
         status: "pending" | "processing" | "completed" | "failed" | "corrupt";
         limit?: number | undefined;
     }>, undefined, AdminTasksResponse>;
-    readonly retryTask: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly retryTask: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         taskId: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         taskId: string;
     }, {
         taskId: string;
     }>, undefined, AdminRetryTaskResponse>;
-    readonly deleteTask: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly deleteTask: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         status: z.ZodEnum<["pending", "failed", "corrupt"]>;
         fileName: z.ZodEffects<z.ZodString, string, string>;
     }, "strip", z.ZodTypeAny, {
@@ -140,4 +140,3 @@ export declare const ADMIN_ROUTES: {
         fileName: string;
     }>, undefined, AdminDeleteTaskResponse>;
 };
-//# sourceMappingURL=admin.d.ts.map

package/dist/api/admin.js

@@ -335,4 +335,3 @@ export const ADMIN_ROUTES = {
     deleteTask,
     ...ADMIN_BRANCH_HEALTH_ROUTES,
 };
-//# sourceMappingURL=admin.js.map

package/dist/api/assets.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import type { ApiResponse } from './types';
-import type { RouteDefinition } from '../http/router';
-import type { AssetMeta, StagedUploadTarget } from '../assets/types';
+import type { ApiResponse } from './types.js';
+import type { RouteDefinition } from '../http/router.js';
+import type { AssetMeta, StagedUploadTarget } from '../assets/types.js';
 /** An asset's persisted meta plus its computed, root-relative public URL. */
 export type AssetRecord = AssetMeta & {
     src: string;
@@ -77,7 +77,7 @@ export type DeleteAssetParams = z.infer<typeof deleteAssetParamsSchema>;
  * Exported routes for router registration and client codegen.
  */
 export declare const ASSET_ROUTES: {
-    readonly presign: import("./route-builder").RouteDefinition<undefined, z.ZodObject<{
+    readonly presign: import("./route-builder.js").RouteDefinition<undefined, z.ZodObject<{
         filename: z.ZodString;
         contentType: z.ZodString;
         size: z.ZodOptional<z.ZodNumber>;
@@ -90,7 +90,7 @@ export declare const ASSET_ROUTES: {
         contentType: string;
         size?: number | undefined;
     }>, PresignAssetResponse>;
-    readonly finalize: import("./route-builder").RouteDefinition<undefined, z.ZodObject<{
+    readonly finalize: import("./route-builder.js").RouteDefinition<undefined, z.ZodObject<{
         stagingKey: z.ZodString;
         filename: z.ZodString;
     }, "strip", z.ZodTypeAny, {
@@ -100,8 +100,8 @@ export declare const ASSET_ROUTES: {
         filename: string;
         stagingKey: string;
     }>, FinalizeAssetResponse>;
-    readonly uploadProxied: import("./route-builder").RouteDefinition<undefined, undefined, FinalizeAssetResponse>;
-    readonly list: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly uploadProxied: import("./route-builder.js").RouteDefinition<undefined, undefined, FinalizeAssetResponse>;
+    readonly list: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         cursor: z.ZodOptional<z.ZodString>;
         limit: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
@@ -111,7 +111,7 @@ export declare const ASSET_ROUTES: {
         cursor?: string | undefined;
         limit?: number | undefined;
     }>, undefined, AssetsListResponse>;
-    readonly delete: import("./route-builder").RouteDefinition<z.ZodObject<{
+    readonly delete: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         key: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         key: string;
@@ -125,4 +125,3 @@ export declare const ASSET_ROUTES: {
  */
 export declare const assetRawRoute: RouteDefinition;
 export {};
-//# sourceMappingURL=assets.d.ts.map

package/dist/api/assets.js

@@ -437,4 +437,3 @@ export const assetRawRoute = {
     pattern: ['assets', 'raw', '...key'],
     handler: rawAssetHandler,
 };
-//# sourceMappingURL=assets.js.map

package/dist/api/branch-merge.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { ApiResponse } from './types';
+import type { ApiResponse } from './types.js';
 export interface MarkAsMergedParams {
     branch: string;
 }
@@ -20,8 +20,8 @@ export type BranchMergeResponse = ApiResponse<{
  * guard lands (and a deployed instance's stranded main has no PR number, so
  * it's refused there too).
  */
-export declare const markAsMerged: import("./route-builder").RouteDefinition<z.ZodObject<{
-    branch: z.ZodType<import("../paths").BranchName, z.ZodTypeDef, import("../paths").BranchName>;
+export declare const markAsMerged: import("./route-builder.js").RouteDefinition<z.ZodObject<{
+    branch: z.ZodType<import("../paths/index.js").BranchName, z.ZodTypeDef, import("../paths/index.js").BranchName>;
 }, "strip", z.ZodTypeAny, {
     branch: string & {
         readonly __brand: "BranchName";
@@ -31,4 +31,3 @@ export declare const markAsMerged: import("./route-builder").RouteDefinition<z.Z
         readonly __brand: "BranchName";
     };
 }>, undefined, BranchMergeResponse>;
-//# sourceMappingURL=branch-merge.d.ts.map

package/dist/api/branch-merge.js

@@ -90,4 +90,3 @@ export const markAsMerged = defineEndpoint({
     guards: ['admin', 'branch'],
     handler: markAsMergedHandler,
 });
-//# sourceMappingURL=branch-merge.js.map