canopycms 0.0.63 → 0.0.65

package/dist/entry-schema.d.ts

@@ -12,13 +12,88 @@ type InferableField = {
         name: string;
         fields: readonly InferableField[];
     }>;
+    /**
+     * For select fields: the option list. Inferring the literal union of these values is
+     * what makes a select field's type its own options rather than a bare `string`.
+     *
+     * MUST stay `readonly` even though `SelectFieldConfig.options` (config/types.ts) is a
+     * mutable `SelectOption[]` — but NOT for the reason you might assume. A mutable
+     * constraint does not defeat `const` inference here: verified against this repo's tsc,
+     * `<const T>` still infers `['a', 'b']` with the literals intact under a mutable
+     * constraint, so the union would survive. The real failure is louder. An adopter who
+     * declares the option list separately and shares it across schemas writes
+     * `as const`, producing a `readonly` tuple — and a `readonly` array is not assignable
+     * to a mutable one (TS4104), so every such schema would stop compiling at the
+     * definition site. `readonly` here accepts both the inline literal and the shared
+     * `as const` array.
+     */
+    options?: readonly (string | {
+        label: string;
+        value: string;
+    })[];
     /** For reference fields: the target collection's schema (from defineEntrySchema) to infer resolved types. */
     resolvedSchema?: readonly InferableField[];
     /** For reference fields: filter by entry type name (e.g., ['partner']). */
     entryTypes?: readonly string[];
     /** For reference fields: collection paths to scope the search. */
     collections?: readonly string[];
+    /** For reference fields: resolve the target's body too. See ReferenceFieldConfig.includeBody. */
+    includeBody?: boolean;
 };
+/**
+ * The fields reference resolution adds to a target's own data, on top of whatever
+ * `resolvedSchema` declares.
+ *
+ * These have always been returned at runtime (`resolveSingleReferenceOnce` in
+ * content-store.ts) but were missing from the inferred type, so a resolved reference typed
+ * narrower than it actually is — which is why reading `ref.id` needed a cast, and one source
+ * of the library-internal type error `adopter-migration.md` records under
+ * `exactOptionalPropertyTypes` + `skipLibCheck: false`.
+ *
+ * `urlPath` is what makes a resolved reference linkable without a second lookup; it follows
+ * the same collection+slug rule `listEntries` publishes as `item.urlPath`, so an index entry
+ * collapses to its parent path.
+ */
+export declare const RESOLVED_REFERENCE_KEYS: readonly ["id", "slug", "collection", "urlPath"];
+/**
+ * Runtime counterpart of {@link ResolvedReferenceMeta}'s keys — the names reference resolution
+ * reserves on a resolved value. Kept beside the type so the two cannot drift, and consumed by
+ * both the resolver (which applies these last, so a target cannot shadow them) and the entry
+ * schema registry (which rejects a body field named one of them, since the body is assigned by
+ * key and would otherwise be the one way around that ordering).
+ */
+export interface ResolvedReferenceMeta {
+    /** The referenced entry's 12-char content ID. */
+    id: string;
+    /** The referenced entry's slug. */
+    slug: string;
+    /** The referenced entry's collection logical path (e.g. `content/snippets`). */
+    collection: string;
+    /** URL path for the referenced entry, e.g. `/guides/getting-started`. */
+    urlPath: string;
+}
+/**
+ * Assemble a resolved reference: the target's own data, then its body if the field asked to
+ * embed it, then the reserved metadata.
+ *
+ * Exists so the two places that construct one — the server resolver in content-store.ts and
+ * the editor's live-preview endpoint in api/resolve-references.ts — cannot drift. They already
+ * had: the preview endpoint kept the old `{ id, ...data }` order and carried none of the other
+ * three keys, so a component rendering `<a href={ref.urlPath}>` showed `undefined` while
+ * previewing and a real URL once published.
+ *
+ * The ordering is the contract, not a detail. Metadata last means a target that models `id` as
+ * a content field cannot shadow the real content ID — which matters because the write boundary
+ * recovers a reference's id from `value.id` (`referenceValueId`), so shadowing it made a
+ * re-save persist the wrong value and silently repoint the reference. Body before metadata
+ * closes the same hole for a body field named `id`; that schema is also rejected outright by
+ * the entry schema registry, so this ordering is the guarantee and that check is the loud
+ * error rather than a silent drop.
+ */
+export declare function buildResolvedReference(data: Record<string, unknown>, meta: ResolvedReferenceMeta, body?: {
+    fieldName: string;
+    value: string | undefined;
+}): Record<string, unknown>;
 /**
  * Recursively flatten inline groups (type: 'group') out of a field tuple so that
  * InferContentShape sees only data-carrying fields. Inline groups contribute no
@@ -46,6 +121,43 @@ type Simplify<T> = {
  * the `?` modifier that InferContentShape applies, never duplicated as `| undefined`.
  */
 type ScalarValue<F extends InferableField, V> = F['list'] extends true ? V[] : V;
+/**
+ * The value one `select` option contributes to the field's value union. A bare string
+ * option contributes itself; a `{ label, value }` option contributes its `value`, not
+ * the whole object. Mixed arrays of both forms work because this distributes.
+ *
+ * Falls back to `string` for an option whose literal type is gone — an options array
+ * annotated as `SelectOption[]` rather than inferred by `defineEntrySchema` widens to
+ * `string | { label: string; value: string }`, and both arms then land on `string`.
+ */
+type SelectOptionValue<O> = O extends {
+    value: infer V extends string;
+} ? V : O extends string ? O : string;
+/**
+ * The value type of a `select` field: the literal union of its OWN `options`.
+ *
+ * A select value is always a string — `SelectOption` (config/types.ts) carries
+ * `value: string` in both arms, `normalizeOptions` (editor/FormRenderer.tsx) emits
+ * strings, and `validateEntryData` (validation/entry-validator.ts) rejects anything
+ * that is not one. This type says WHICH strings.
+ *
+ * Like the rest of InferContentShape, this models the SCHEMA'S declared shape, not
+ * every byte the validator will tolerate on disk — the same stance that types a field
+ * omitting `required` as a required property. Notably the validator also accepts `''`
+ * as "not filled in" for any field that is not explicitly `required: true`, and `''` is
+ * deliberately NOT in this union.
+ *
+ * Degrades to `string` when there is nothing to infer: no `options` key at all, or an
+ * empty one. Both are schema mistakes that `ensureSelectFieldsHaveOptions`
+ * (config/validation.ts) rejects — but note it runs from `createEntrySchemaRegistry`,
+ * NOT from `validateCanopyConfig`, so a schema that is only ever fed to
+ * `TypeFromEntrySchema` and never registered gets no runtime rejection at all.
+ * Returning `never` here would type such a field as unsatisfiable, which is a worse
+ * error than the bare `string` this falls back to.
+ */
+type SelectValue<F extends InferableField> = F extends {
+    options: infer O extends readonly unknown[];
+} ? [O[number]] extends [never] ? string : SelectOptionValue<O[number]> : string;
 type ObjectValue<F extends InferableField & {
     fields: readonly InferableField[];
 }> = F['list'] extends true ? Array<InferContentShape<F['fields']>> : InferContentShape<F['fields']>;
@@ -102,10 +214,10 @@ type FieldValue<F extends InferableField> = F extends {
     }>>>;
 }> : F extends {
     type: 'select';
-} ? ScalarValue<F, string | number> : F extends {
+} ? ScalarValue<F, SelectValue<F>> : F extends {
     type: 'reference';
     resolvedSchema: infer S;
-} ? ScalarValue<F, InferContentShape<Extract<S, readonly InferableField[]>> | null> : F extends {
+} ? ScalarValue<F, (InferContentShape<Extract<S, readonly InferableField[]>> & ResolvedReferenceMeta) | null> : F extends {
     type: 'reference';
 } ? ScalarValue<F, string | null> : F extends {
     type: 'image';
@@ -471,4 +583,3 @@ export type BlockComponentRegistry<Blocks extends {
  */
 export declare const defineFieldFragment: <const T extends readonly InferableField[]>(fields: T) => T;
 export {};
-//# sourceMappingURL=entry-schema.d.ts.map

package/dist/entry-schema.js

@@ -1,6 +1,52 @@
 // The recommended SEO field names, shared with the read side (extractSeoFields) so the schema
 // this module emits and the fields that module looks for cannot drift apart.
 import { DEFAULT_SEO_FIELD_NAMES } from './static/seo.js';
+/**
+ * The fields reference resolution adds to a target's own data, on top of whatever
+ * `resolvedSchema` declares.
+ *
+ * These have always been returned at runtime (`resolveSingleReferenceOnce` in
+ * content-store.ts) but were missing from the inferred type, so a resolved reference typed
+ * narrower than it actually is — which is why reading `ref.id` needed a cast, and one source
+ * of the library-internal type error `adopter-migration.md` records under
+ * `exactOptionalPropertyTypes` + `skipLibCheck: false`.
+ *
+ * `urlPath` is what makes a resolved reference linkable without a second lookup; it follows
+ * the same collection+slug rule `listEntries` publishes as `item.urlPath`, so an index entry
+ * collapses to its parent path.
+ */
+export const RESOLVED_REFERENCE_KEYS = ['id', 'slug', 'collection', 'urlPath'];
+/**
+ * Assemble a resolved reference: the target's own data, then its body if the field asked to
+ * embed it, then the reserved metadata.
+ *
+ * Exists so the two places that construct one — the server resolver in content-store.ts and
+ * the editor's live-preview endpoint in api/resolve-references.ts — cannot drift. They already
+ * had: the preview endpoint kept the old `{ id, ...data }` order and carried none of the other
+ * three keys, so a component rendering `<a href={ref.urlPath}>` showed `undefined` while
+ * previewing and a real URL once published.
+ *
+ * The ordering is the contract, not a detail. Metadata last means a target that models `id` as
+ * a content field cannot shadow the real content ID — which matters because the write boundary
+ * recovers a reference's id from `value.id` (`referenceValueId`), so shadowing it made a
+ * re-save persist the wrong value and silently repoint the reference. Body before metadata
+ * closes the same hole for a body field named `id`; that schema is also rejected outright by
+ * the entry schema registry, so this ordering is the guarantee and that check is the loud
+ * error rather than a silent drop.
+ */
+export function buildResolvedReference(data, meta, body) {
+    const resolved = { ...data };
+    // Truthiness, matching `readEntryData`'s own merge: a listed md entry with an empty body
+    // carries no body key, so resolving one to `''` would reintroduce a listed-vs-resolved
+    // shape disagreement.
+    if (body && body.value)
+        resolved[body.fieldName] = body.value;
+    resolved.id = meta.id;
+    resolved.slug = meta.slug;
+    resolved.collection = meta.collection;
+    resolved.urlPath = meta.urlPath;
+    return resolved;
+}
 /**
  * Helper to define entry schema field arrays with literal inference without sprinkling `as const`.
  */
@@ -202,4 +248,3 @@ export const defineBlockTemplate = (template) => template;
  * ])
  */
 export const defineFieldFragment = (fields) => fields;
-//# sourceMappingURL=entry-schema.js.map

package/dist/git-manager.d.ts

@@ -1,5 +1,5 @@
 import { type SimpleGitOptions, type StatusResult } from 'simple-git';
-import type { OperatingMode } from './operating-mode';
+import type { OperatingMode } from './operating-mode/index.js';
 /**
  * Exported for GitManager's own use (see `this.git.env(...)` above),
  * worker/cms-worker.ts's push-rejection-classified GitHub calls
@@ -423,4 +423,3 @@ export declare class GitManager {
     createOrphanSettingsBranch(branchName: string, initialFiles: Record<string, string>): Promise<void>;
     private createOrphanSettingsBranchInner;
 }
-//# sourceMappingURL=git-manager.d.ts.map

package/dist/git-manager.js

@@ -1282,4 +1282,3 @@ export class GitManager {
         log.debug('git', 'Orphan settings branch created', { branchName });
     }
 }
-//# sourceMappingURL=git-manager.js.map

package/dist/github-service.d.ts

@@ -1,5 +1,5 @@
 import { Octokit } from '@octokit/rest';
-import type { CanopyConfig } from './config';
+import type { CanopyConfig } from './config/index.js';
 /**
  * Retry primary rate limits at most twice and only for short waits; beyond
  * that, task-level retry/backoff (worker) or the caller's error path takes
@@ -156,4 +156,3 @@ export declare class GitHubService {
  * Returns null if not applicable (missing token, not GitHub, etc.)
  */
 export declare const createGitHubService: (config: CanopyConfig, remoteUrl?: string) => GitHubService | null;
-//# sourceMappingURL=github-service.d.ts.map

package/dist/github-service.js

@@ -359,4 +359,3 @@ export const createGitHubService = (config, remoteUrl) => {
         return null;
     }
 };
-//# sourceMappingURL=github-service.js.map

package/dist/http/handler.d.ts

@@ -1,9 +1,9 @@
-import type { CanopyBinaryResponse, CanopyRequest, CanopyResponse } from './types';
-import type { ApiContext, ApiResponse } from '../api/types';
-import { type AuthPlugin } from '../auth/plugin';
-import { type CanopyServices } from '../services';
-import type { CanopyConfig } from '../config';
-import type { BranchContext } from '../types';
+import type { CanopyBinaryResponse, CanopyRequest, CanopyResponse } from './types.js';
+import type { ApiContext, ApiResponse } from '../api/types.js';
+import { type AuthPlugin } from '../auth/plugin.js';
+import { type CanopyServices } from '../services.js';
+import type { CanopyConfig } from '../config/index.js';
+import type { BranchContext } from '../types.js';
 /**
  * Options for creating a Canopy request handler.
  * This is framework-agnostic - adapters convert their framework's
@@ -57,4 +57,3 @@ export declare function createCanopyRequestHandler(options: CanopyHandlerOptions
 export declare function createCanopyRequestHandlerFromConfig(options: {
     config: CanopyConfig;
 } & Omit<CanopyHandlerOptions, 'services' | 'config'>): Promise<CanopyRequestHandler>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/http/handler.js

@@ -321,4 +321,3 @@ export async function createCanopyRequestHandlerFromConfig(options) {
         services: await createCanopyServices(options.config),
     });
 }
-//# sourceMappingURL=handler.js.map

package/dist/http/index.d.ts

@@ -1,7 +1,6 @@
-export type { CanopyRequest, CanopyResponse, CanopyBinaryResponse } from './types';
-export { jsonResponse, isCanopyBinaryResponse } from './types';
-export type { CanopyHandler, RouteDefinition, RouteMatch, CanopyRouter } from './router';
-export { createCanopyRouter } from './router';
-export type { CanopyHandlerOptions, CanopyRequestHandler } from './handler';
-export { createCanopyRequestHandler, createCanopyRequestHandlerFromConfig } from './handler';
-//# sourceMappingURL=index.d.ts.map
+export type { CanopyRequest, CanopyResponse, CanopyBinaryResponse } from './types.js';
+export { jsonResponse, isCanopyBinaryResponse } from './types.js';
+export type { CanopyHandler, RouteDefinition, RouteMatch, CanopyRouter } from './router.js';
+export { createCanopyRouter } from './router.js';
+export type { CanopyHandlerOptions, CanopyRequestHandler } from './handler.js';
+export { createCanopyRequestHandler, createCanopyRequestHandlerFromConfig } from './handler.js';

package/dist/http/index.js

@@ -1,4 +1,3 @@
 export { jsonResponse, isCanopyBinaryResponse } from './types.js';
 export { createCanopyRouter } from './router.js';
 export { createCanopyRequestHandler, createCanopyRequestHandlerFromConfig } from './handler.js';
-//# sourceMappingURL=index.js.map

package/dist/http/router.d.ts

@@ -1,5 +1,5 @@
-import type { ApiResponse } from '../api/types';
-import type { CanopyBinaryResponse } from './types';
+import type { ApiResponse } from '../api/types.js';
+import type { CanopyBinaryResponse } from './types.js';
 /**
  * Handler function signature for Canopy API routes.
  * Uses `any` to accommodate different handler signatures in the codebase.
@@ -70,4 +70,3 @@ export declare function matchRoute(routes: readonly RouteDefinition[], method: s
  * Create the standard Canopy router with all API routes.
  */
 export declare function createCanopyRouter(): CanopyRouter;
-//# sourceMappingURL=router.d.ts.map

package/dist/http/router.js

@@ -203,4 +203,3 @@ export function createCanopyRouter() {
         match: (method, segments) => matchRoute(routes, method, segments),
     };
 }
-//# sourceMappingURL=router.js.map

package/dist/http/types.d.ts

@@ -71,4 +71,3 @@ export declare function jsonResponse<T>(body: T, status?: number, headers?: Reco
  * pass a route result through untouched or wrap it via `jsonResponse`.
  */
 export declare function isCanopyBinaryResponse(value: unknown): value is CanopyBinaryResponse;
-//# sourceMappingURL=types.d.ts.map

package/dist/http/types.js

@@ -13,4 +13,3 @@ export function jsonResponse(body, status = 200, headers) {
 export function isCanopyBinaryResponse(value) {
     return (typeof value === 'object' && value !== null && value.kind === 'binary');
 }
-//# sourceMappingURL=types.js.map

package/dist/id.d.ts

@@ -1,5 +1,5 @@
-import type { ContentId } from './paths/types';
-import { isValidContentId } from './paths/validation';
+import type { ContentId } from './paths/types.js';
+import { isValidContentId } from './paths/validation.js';
 /**
  * Generate a new 12-character content ID.
  * Uses Base58-encoded UUID, truncated for shorter filenames.
@@ -14,4 +14,3 @@ export declare function generateId(): ContentId;
  * Standard format: 12 characters using Base58 alphabet (no ambiguous characters: 0, O, I, l).
  */
 export declare const isValidId: typeof isValidContentId;
-//# sourceMappingURL=id.d.ts.map

package/dist/id.js

@@ -17,4 +17,3 @@ export function generateId() {
  * Standard format: 12 characters using Base58 alphabet (no ambiguous characters: 0, O, I, l).
  */
 export const isValidId = isValidContentId;
-//# sourceMappingURL=id.js.map

package/dist/index.d.ts

@@ -1,18 +1,17 @@
-export { sanitizeHref } from './utils/sanitize-href';
-export * from './config';
-export * from './entry-schema';
-export * from './types';
-export * from './user';
-export { resolveEntryTitle } from './utils/title-field';
-export { defineAIContentConfig } from './ai/types';
-export type { AIContentConfig, ExcludeConfig, BundleConfig, BundleFilter, FieldTransformFn, FieldTransforms, } from './ai/types';
-export type { AuthPlugin, AuthPluginFactory } from './auth/plugin';
-export type { UserSearchResult, GroupMetadata, AuthenticationResult } from './auth/types';
-export { isCanopyRequest, isHeadersLike, extractHeaders, validateAuthContext, } from './auth/context-helpers';
-export type { HeadersLike } from './auth/context-helpers';
-export type { ContentTreeNode, BuildContentTreeOptions, ContentTreeExtractMeta, EntryTypeMap, DefaultEntryTypes, } from './content-tree';
-export type { ListEntriesItem, ListEntriesOptions } from './content-listing';
-export { assetUrl, assetSrcSet } from './assets/asset-url';
-export type { AssetRef, AssetUrlOptions } from './assets/asset-url';
-export type { OutputFormat, CropRect, TransformDirectives } from './assets/transform-directives';
-//# sourceMappingURL=index.d.ts.map
+export { sanitizeHref } from './utils/sanitize-href.js';
+export * from './config/index.js';
+export * from './entry-schema.js';
+export * from './types.js';
+export * from './user.js';
+export { resolveEntryTitle } from './utils/title-field.js';
+export { defineAIContentConfig } from './ai/types.js';
+export type { AIContentConfig, ExcludeConfig, BundleConfig, BundleFilter, FieldTransformFn, FieldTransforms, } from './ai/types.js';
+export type { AuthPlugin, AuthPluginFactory } from './auth/plugin.js';
+export type { UserSearchResult, GroupMetadata, AuthenticationResult } from './auth/types.js';
+export { isCanopyRequest, isHeadersLike, extractHeaders, validateAuthContext, } from './auth/context-helpers.js';
+export type { HeadersLike } from './auth/context-helpers.js';
+export type { ContentTreeNode, BuildContentTreeOptions, ContentTreeExtractMeta, EntryTypeMap, DefaultEntryTypes, } from './content-tree.js';
+export type { ListEntriesItem, ListEntriesOptions } from './content-listing.js';
+export { assetUrl, assetSrcSet } from './assets/asset-url.js';
+export type { AssetRef, AssetUrlOptions } from './assets/asset-url.js';
+export type { OutputFormat, CropRect, TransformDirectives } from './assets/transform-directives.js';

package/dist/index.js

@@ -18,4 +18,3 @@ export { isCanopyRequest, isHeadersLike, extractHeaders, validateAuthContext, }
 // URLs for <img>/srcset from stored asset refs without pulling in the
 // server-only transform engine (canopycms's assets/transform.ts, sharp).
 export { assetUrl, assetSrcSet } from './assets/asset-url.js';
-//# sourceMappingURL=index.js.map

package/dist/operating-mode/client-safe-strategy.d.ts

@@ -6,7 +6,7 @@
  *
  * These classes are extended by client-unsafe strategies to add Node.js functionality.
  */
-import type { OperatingMode, ClientSafeStrategy } from './types';
+import type { OperatingMode, ClientSafeStrategy } from './types.js';
 export declare class ProdClientSafeStrategy implements ClientSafeStrategy {
     readonly mode: OperatingMode;
     supportsBranching(): boolean;
@@ -43,4 +43,3 @@ export declare function clientOperatingStrategy(mode: OperatingMode): ClientSafe
  * Clear the client strategy cache (mainly for testing)
  */
 export declare function clearClientStrategyCache(): void;
-//# sourceMappingURL=client-safe-strategy.d.ts.map

package/dist/operating-mode/client-safe-strategy.js

@@ -114,4 +114,3 @@ export function clientOperatingStrategy(mode) {
 export function clearClientStrategyCache() {
     clientStrategyCache.clear();
 }
-//# sourceMappingURL=client-safe-strategy.js.map

package/dist/operating-mode/client-unsafe-strategy.d.ts

@@ -6,7 +6,7 @@
  *
  * These classes inherit all client-safe methods and add client-unsafe functionality.
  */
-import type { OperatingMode, ClientUnsafeStrategy } from './types';
+import type { OperatingMode, ClientUnsafeStrategy } from './types.js';
 /**
  * Get the full strategy (client-unsafe) for an operating mode.
  *
@@ -23,4 +23,3 @@ export declare function operatingStrategy(mode: OperatingMode): ClientUnsafeStra
  * Clear the strategy cache (mainly for testing)
  */
 export declare function clearStrategyCache(): void;
-//# sourceMappingURL=client-unsafe-strategy.d.ts.map

package/dist/operating-mode/client-unsafe-strategy.js

@@ -169,4 +169,3 @@ export function operatingStrategy(mode) {
 export function clearStrategyCache() {
     strategyCache.clear();
 }
-//# sourceMappingURL=client-unsafe-strategy.js.map

package/dist/operating-mode/client.d.ts

@@ -7,7 +7,6 @@
  * Usage in client components:
  *   import { clientOperatingStrategy } from '@/operating-mode/client'
  */
-export { clientOperatingStrategy, clearClientStrategyCache } from './client-safe-strategy';
-export type { ClientSafeStrategy } from './types';
-export type { OperatingMode } from './types';
-//# sourceMappingURL=client.d.ts.map
+export { clientOperatingStrategy, clearClientStrategyCache } from './client-safe-strategy.js';
+export type { ClientSafeStrategy } from './types.js';
+export type { OperatingMode } from './types.js';

package/dist/operating-mode/client.js

@@ -8,4 +8,3 @@
  *   import { clientOperatingStrategy } from '@/operating-mode/client'
  */
 export { clientOperatingStrategy, clearClientStrategyCache } from './client-safe-strategy.js';
-//# sourceMappingURL=client.js.map

package/dist/operating-mode/deployment-name-fixtures.d.ts

@@ -26,4 +26,3 @@ export declare const VALID_DEPLOYMENT_NAMES: readonly ["prod", "staging", "acme-
  * that would corrupt the worker's `.env` heredoc.
  */
 export declare const INVALID_DEPLOYMENT_NAMES: readonly [readonly ["a slash (would add a ref hierarchy level)", "team/prod"], readonly ["whitespace", "my prod"], readonly ["a leading dash (parses as a git option)", "-prod"], readonly ["a git-forbidden character", "prod:1"], readonly ["dot-dot", "a..b"], readonly ["a leading dot", ".prod"], readonly ["a trailing dot", "prod."], readonly ["a .lock suffix", "prod.lock"], readonly ["a tilde", "prod~1"], readonly ["a caret", "prod^1"], readonly ["a question mark", "prod?"], readonly ["an asterisk", "prod*"], readonly ["an open bracket", "prod["], readonly ["a backslash", "prod\\1"], readonly ["the empty string", ""], readonly ["a newline (would inject a line into the worker .env)", "prod\nEVIL=1"]];
-//# sourceMappingURL=deployment-name-fixtures.d.ts.map

package/dist/operating-mode/deployment-name-fixtures.js

@@ -52,4 +52,3 @@ export const INVALID_DEPLOYMENT_NAMES = [
     ['the empty string', ''],
     ['a newline (would inject a line into the worker .env)', 'prod\nEVIL=1'],
 ];
-//# sourceMappingURL=deployment-name-fixtures.js.map

package/dist/operating-mode/deployment-name.d.ts

@@ -34,4 +34,3 @@ export declare const isValidDeploymentName: (name: string) => boolean;
 export declare function resolveDeploymentName(config: {
     deploymentName?: string;
 }, modeDefault: string): string;
-//# sourceMappingURL=deployment-name.d.ts.map

package/dist/operating-mode/deployment-name.js

@@ -83,4 +83,3 @@ export function resolveDeploymentName(config, modeDefault) {
     }
     return resolved;
 }
-//# sourceMappingURL=deployment-name.js.map

package/dist/operating-mode/index.d.ts

@@ -24,10 +24,9 @@
  *   const settingsRoot = strategy.getSettingsRoot()
  *   if (strategy.supportsBranching()) { ... } // can also use client-safe methods
  */
-export { clientOperatingStrategy, clearClientStrategyCache } from './client-safe-strategy';
-export { operatingStrategy, clearStrategyCache } from './client-unsafe-strategy';
-export { resolveDeploymentName, isValidDeploymentName } from './deployment-name';
-export { resolveOperatingMode, SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR } from './mode-env';
+export { clientOperatingStrategy, clearClientStrategyCache } from './client-safe-strategy.js';
+export { operatingStrategy, clearStrategyCache } from './client-unsafe-strategy.js';
+export { resolveDeploymentName, isValidDeploymentName } from './deployment-name.js';
+export { resolveOperatingMode, SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR } from './mode-env.js';
 export type OperatingMode = 'prod' | 'dev';
-export type { ClientSafeStrategy, ClientUnsafeStrategy, ResolveRemoteUrlOptions } from './types';
-//# sourceMappingURL=index.d.ts.map
+export type { ClientSafeStrategy, ClientUnsafeStrategy, ResolveRemoteUrlOptions } from './types.js';

package/dist/operating-mode/index.js

@@ -34,4 +34,3 @@ export { resolveDeploymentName, isValidDeploymentName } from './deployment-name.
 // Single resolution point for `mode` (env > config.mode) — isomorphic, applied
 // inside validateCanopyConfig so every config-authoring path gets it.
 export { resolveOperatingMode, SERVER_MODE_ENV_VAR, BROWSER_MODE_ENV_VAR } from './mode-env.js';
-//# sourceMappingURL=index.js.map

package/dist/operating-mode/mode-env.d.ts

@@ -43,7 +43,7 @@
  * running header-trusting dev auth semantics — the exact failure SEC-C1 made
  * `mode` required to prevent.
  */
-import type { OperatingMode } from './types';
+import type { OperatingMode } from './types.js';
 export declare const SERVER_MODE_ENV_VAR = "CANOPY_MODE";
 export declare const BROWSER_MODE_ENV_VAR = "NEXT_PUBLIC_CANOPY_MODE";
 /** Reset the once-per-process warning latch. Test-only. */
@@ -55,4 +55,3 @@ export declare function resetModeWarning(): void;
  * through.
  */
 export declare function resolveOperatingMode(configMode: OperatingMode): OperatingMode;
-//# sourceMappingURL=mode-env.d.ts.map

package/dist/operating-mode/mode-env.js

@@ -94,4 +94,3 @@ export function resolveOperatingMode(configMode) {
     }
     return env.value;
 }
-//# sourceMappingURL=mode-env.js.map

package/dist/operating-mode/types.d.ts

@@ -5,8 +5,8 @@
  * - ClientSafeStrategy: Methods safe for client-side bundles (no Node.js APIs)
  * - ClientUnsafeStrategy: Full strategy with Node.js APIs (server-side only)
  */
-import type { OperatingMode as OM } from '.';
-import type { CanopyConfig } from '../config';
+import type { OperatingMode as OM } from './index.js';
+import type { CanopyConfig } from '../config/index.js';
 export type OperatingMode = OM;
 /**
  * Options for resolving git remote URL
@@ -141,4 +141,3 @@ export interface ClientUnsafeStrategy extends ClientSafeStrategy {
         autoCreateSettingsPR?: boolean;
     }): boolean;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/operating-mode/types.js

@@ -6,4 +6,3 @@
  * - ClientUnsafeStrategy: Full strategy with Node.js APIs (server-side only)
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/paths/branch-name.d.ts

@@ -9,7 +9,7 @@
  * import in that graph breaks adopters' production `next build` of the
  * editor bundle. Same pattern as assets/asset-prefixes.ts.
  */
-import type { SanitizedBranchName } from './types';
+import type { SanitizedBranchName } from './types.js';
 /**
  * Sanitize a branch name for use in filesystem paths.
  * - Replaces invalid characters with hyphens
@@ -55,4 +55,3 @@ export declare const RESERVED_SETTINGS_BRANCH_PREFIX = "canopycms-settings-";
  * a new top-level namespace fails that test until this list is updated.
  */
 export declare const RESERVED_ROUTE_BRANCH_NAMES: readonly string[];
-//# sourceMappingURL=branch-name.d.ts.map

package/dist/paths/branch-name.js

@@ -67,4 +67,3 @@ export const RESERVED_ROUTE_BRANCH_NAMES = [
     'users',
     'whoami',
 ];
-//# sourceMappingURL=branch-name.js.map

package/dist/paths/branch.d.ts

@@ -3,8 +3,8 @@
  *
  * Handles resolving branch names to workspace directories.
  */
-import type { BranchContext } from '../types';
-import { OperatingMode } from '../operating-mode';
+import type { BranchContext } from '../types.js';
+import { OperatingMode } from '../operating-mode/index.js';
 export interface BranchPathOptions {
     mode: OperatingMode;
     branchName: string;
@@ -17,7 +17,7 @@ export interface BranchPathResult {
 }
 export declare class BranchPathError extends Error {
 }
-import { sanitizeBranchName } from './branch-name';
+import { sanitizeBranchName } from './branch-name.js';
 export { sanitizeBranchName };
 /**
  * Resolve branch name to workspace paths.
@@ -36,4 +36,3 @@ export declare function getDefaultBranchBase(mode: OperatingMode, override?: str
  * Resolve branch paths from a branch context.
  */
 export declare function resolveBranchPaths(branchContext: BranchContext, mode: OperatingMode, basePathOverride?: string): BranchPathResult;
-//# sourceMappingURL=branch.d.ts.map

package/dist/paths/branch.js

@@ -75,4 +75,3 @@ export function resolveBranchPaths(branchContext, mode, basePathOverride) {
         basePathOverride,
     });
 }
-//# sourceMappingURL=branch.js.map

package/dist/paths/index.d.ts

@@ -10,14 +10,13 @@
  *
  * Usage:
  * ```ts
- * import { normalizeFilesystemPath, createLogicalPath, parseSlug } from '../paths'
+ * import { normalizeFilesystemPath, createLogicalPath, parseSlug } from '../paths/index.js'
  * ```
  */
-export type { LogicalPath, PhysicalPath, SanitizedBranchName, BranchName, ContentId, Slug, PathValidationResult, } from './types';
-export { normalizeFilesystemPath, normalizeCollectionPath, hasTraversalSequence, createLogicalPath, createPhysicalPath, joinPath, trimSlashes, } from './normalize';
-export { validateAndNormalizePath } from './normalize-server';
-export { validateContentPath, isValidCollectionPath, sanitizeForPath, hasEmbeddedContentId, looksLikePhysicalPath, looksLikeLogicalPath, parseLogicalPath, parsePhysicalPath, isValidContentId, parseContentId, parseBranchName, parseSlug, } from './validation';
-export { resolveLogicalPath } from './resolve';
-export { resolveBranchPath, ensureBranchRoot, getDefaultBranchBase, resolveBranchPaths, BranchPathError, type BranchPathOptions, type BranchPathResult, } from './branch';
-export { sanitizeBranchName, RESERVED_SETTINGS_BRANCH_PREFIX, RESERVED_ROUTE_BRANCH_NAMES, } from './branch-name';
-//# sourceMappingURL=index.d.ts.map
+export type { LogicalPath, PhysicalPath, SanitizedBranchName, BranchName, ContentId, Slug, PathValidationResult, } from './types.js';
+export { normalizeFilesystemPath, normalizeCollectionPath, hasTraversalSequence, createLogicalPath, createPhysicalPath, joinPath, trimSlashes, } from './normalize.js';
+export { validateAndNormalizePath } from './normalize-server.js';
+export { validateContentPath, isValidCollectionPath, sanitizeForPath, hasEmbeddedContentId, looksLikePhysicalPath, looksLikeLogicalPath, parseLogicalPath, parsePhysicalPath, isValidContentId, parseContentId, parseBranchName, parseSlug, } from './validation.js';
+export { resolveLogicalPath } from './resolve.js';
+export { resolveBranchPath, ensureBranchRoot, getDefaultBranchBase, resolveBranchPaths, BranchPathError, type BranchPathOptions, type BranchPathResult, } from './branch.js';
+export { sanitizeBranchName, RESERVED_SETTINGS_BRANCH_PREFIX, RESERVED_ROUTE_BRANCH_NAMES, } from './branch-name.js';