@cosmicdrift/kumiko-framework 0.388.0 → 0.390.0

package/dist/engine/feature-ast/render.js

@@ -1,662 +0,0 @@
-// Pattern → TS-Source renderer. Produces canonical Object-Form for every
-// FeaturePattern kind: a single object-literal argument per r.* call.
-// Output is biome-format-stable so consumers can write the file directly
-// without an extra format pass.
-//
-// **Source-of-Truth Contract:**
-//   - Static patterns (entity, nav, config, etc.) round-trip cleanly:
-//     parse → render → parse yields the same patterns.
-//   - Mixed patterns (writeHandler, hook, screen) embed the original
-//     source-text of opaque bodies (handler/fn/closure) verbatim via
-//     SourceLocation.raw — the renderer doesn't re-print closure code.
-//   - Patterns carrying a RawRefSentinel value (e.g. entity/metric/secret
-//     `definition`/`options`) or a `*NameRaw` identifier reference
-//     (useExtension/defineEvent/extendsRegistrar) fall back to positional-arg
-//     form instead of Object-Form, since the raw source text can't be spread
-//     into a merged object literal without losing its verbatim-ness.
-//   - Comments inside an existing pattern are NOT preserved (Designer
-//     edits via forms; for AI generation the output is fresh anyway).
-//
-// **Schema-Version-Header:** every renderFeatureFile output starts with
-// `// kumiko-feature-version: 1`. Future format bumps run a dedicated
-// migrator over the version comment.
-import { isRawRefSentinel } from "./extractors/shared.js";
-import { SCREEN_OPAQUE_MARKER } from "./patterns.js";
-export const FEATURE_FILE_VERSION = 1;
-export const VERSION_HEADER = `// kumiko-feature-version: ${FEATURE_FILE_VERSION}`;
-/**
- * Render a single FeaturePattern back to TypeScript source — a `r.<kind>(...)`
- * call in canonical Object-Form. The result is a single statement WITHOUT a
- * trailing newline; callers compose statements with their own joiner.
- */
-export function renderPattern(pattern) {
-    return renderPatternOfKind(pattern.kind, pattern);
-}
-const PATTERN_RENDERERS = {
-    requires: renderRequires,
-    optionalRequires: renderOptionalRequires,
-    readsConfig: renderReadsConfig,
-    systemScope: renderSystemScope,
-    toggleable: renderToggleable,
-    describe: renderDescribe,
-    uiHints: renderUiHints,
-    entity: renderEntity,
-    relation: renderRelation,
-    nav: renderNav,
-    workspace: renderWorkspace,
-    config: renderConfig,
-    translations: renderTranslations,
-    metric: renderMetric,
-    secret: renderSecret,
-    secretNamespace: renderSecretNamespace,
-    claimKey: renderClaimKey,
-    referenceData: renderReferenceData,
-    useExtension: renderUseExtension,
-    screen: renderScreen,
-    writeHandler: renderWriteHandler,
-    queryHandler: renderQueryHandler,
-    streamHandler: renderStreamHandler,
-    hook: renderHook,
-    job: renderJob,
-    notification: renderNotification,
-    authClaims: renderAuthClaims,
-    httpRoute: renderHttpRoute,
-    projection: renderProjection,
-    multiStreamProjection: renderMultiStreamProjection,
-    defineEvent: renderDefineEvent,
-    extendsRegistrar: renderExtendsRegistrar,
-    usesApi: renderUsesApi,
-    exposesApi: renderExposesApi,
-    treeActions: renderTreeActions,
-    envSchema: renderEnvSchema,
-    "ai.generate": renderAiGenerate,
-    "ai.extract": renderAiExtract,
-    "ai.classify": renderAiClassify,
-    unknown: renderUnknown,
-};
-function renderPatternOfKind(kind, pattern) {
-    return PATTERN_RENDERERS[kind](pattern);
-}
-// =============================================================================
-// JSON-Like Value Renderer — emits TypeScript-source-compatible literals.
-// Used for declarative pattern bodies (entity definitions, config keys, etc.).
-// =============================================================================
-/**
- * Threshold above which a single-line array/object renders multi-line.
- * Biome's default print-width is 100 columns; we leave a margin so a
- * pattern at indent=4 still fits before wrapping. Short arrays/objects
- * stay on one line, long ones go multi-line — biome-stable in both.
- */
-const SINGLE_LINE_WIDTH = 80;
-/**
- * Render a JSON-compatible value as TypeScript source. Matches what
- * `readDataLiteralNode` accepts on the parser side: strings, numbers,
- * booleans, null, arrays, plain objects. Unsupported values (functions,
- * undefined) throw — they should never reach here for a static pattern.
- *
- * Keys are quoted only when they are not valid JS identifiers. The
- * renderer prefers single-line output for short arrays/objects (≤80
- * chars including indent and no nested newlines) and falls back to
- * multi-line otherwise — biome-stable in both branches.
- */
-export function renderValue(value, indent = 0) {
-    if (isRawRefSentinel(value))
-        return value.__raw;
-    if (value === null)
-        return "null";
-    if (typeof value === "string")
-        return JSON.stringify(value);
-    if (typeof value === "number" || typeof value === "boolean")
-        return String(value);
-    if (Array.isArray(value)) {
-        if (value.length === 0)
-            return "[]";
-        const items = value.map((v) => renderValue(v, indent + 2));
-        const singleLine = `[${items.join(", ")}]`;
-        if (singleLine.length + indent <= SINGLE_LINE_WIDTH && !singleLine.includes("\n")) {
-            return singleLine;
-        }
-        const inner = items.map((item) => `${spaces(indent + 2)}${item}`).join(",\n");
-        return `[\n${inner},\n${spaces(indent)}]`;
-    }
-    if (typeof value === "object") {
-        const entries = Object.entries(value);
-        if (entries.length === 0)
-            return "{}";
-        const items = entries.map(([k, v]) => `${renderKey(k)}: ${renderValue(v, indent + 2)}`);
-        const singleLine = `{ ${items.join(", ")} }`;
-        if (singleLine.length + indent <= SINGLE_LINE_WIDTH && !singleLine.includes("\n")) {
-            return singleLine;
-        }
-        const inner = items.map((item) => `${spaces(indent + 2)}${item}`).join(",\n");
-        return `{\n${inner},\n${spaces(indent)}}`;
-    }
-    throw new Error(`renderValue: unsupported type for value ${String(value)}`);
-}
-const VALID_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-function renderKey(key) {
-    return VALID_IDENT.test(key) ? key : JSON.stringify(key);
-}
-function spaces(n) {
-    return " ".repeat(n);
-}
-// =============================================================================
-// Static patterns
-// =============================================================================
-function renderRequires(p) {
-    return `r.requires({ features: ${renderValue([...p.featureNames])} });`;
-}
-function renderOptionalRequires(p) {
-    return `r.optionalRequires({ features: ${renderValue([...p.featureNames])} });`;
-}
-function renderReadsConfig(p) {
-    return `r.readsConfig({ keys: ${renderValue([...p.qualifiedKeys])} });`;
-}
-function renderSystemScope(_p) {
-    return "r.systemScope();";
-}
-function renderToggleable(p) {
-    return `r.toggleable({ default: ${p.default} });`;
-}
-function renderDescribe(p) {
-    return `r.describe(${JSON.stringify(p.text)});`;
-}
-function renderEntity(p) {
-    // A whole-value raw-ref (`eventEntity`) can't go through renderValue without
-    // losing `name` to the sentinel shortcut — spread the reference verbatim
-    // next to the name instead.
-    if (isRawRefSentinel(p.definition)) {
-        const backingTable = p.backingTable ? `, backingTable: ${p.backingTable.__raw}` : "";
-        return `r.entity({ name: ${JSON.stringify(p.entityName)}, ...${p.definition.__raw}${backingTable} });`;
-    }
-    const merged = { name: p.entityName, ...p.definition };
-    return `r.entity(${renderValue(merged)});`;
-}
-function renderRelation(p) {
-    if (isRawRefSentinel(p.definition)) {
-        return `r.relation(${JSON.stringify(p.entityName)}, ${JSON.stringify(p.relationName)}, ${p.definition.__raw});`;
-    }
-    const merged = { entity: p.entityName, name: p.relationName, ...p.definition };
-    return `r.relation(${renderValue(merged)});`;
-}
-function renderNav(p) {
-    return `r.nav(${renderValue(p.definition)});`;
-}
-function renderWorkspace(p) {
-    return `r.workspace(${renderValue(p.definition)});`;
-}
-function renderConfig(p) {
-    return `r.config(${renderValue({ keys: p.keys })});`;
-}
-function renderTranslations(p) {
-    return `r.translations(${renderValue({ keys: p.keys })});`;
-}
-function renderMetric(p) {
-    if (isRawRefSentinel(p.options)) {
-        return `r.metric(${JSON.stringify(p.shortName)}, ${p.options.__raw});`;
-    }
-    const merged = { name: p.shortName, ...p.options };
-    return `r.metric(${renderValue(merged)});`;
-}
-// r.secret / r.secretNamespace throw on an empty writeRoles list; the designer's
-// string-list input emits [] when cleared, which means "rely on handler access alone".
-function dropEmptyWriteRoles(options) {
-    if (options.writeRoles?.length !== 0)
-        return options;
-    const { writeRoles: _emptyWriteRoles, ...rest } = options;
-    return rest;
-}
-function renderSecret(p) {
-    if (isRawRefSentinel(p.options)) {
-        return `r.secret(${JSON.stringify(p.shortName)}, ${p.options.__raw});`;
-    }
-    const merged = { name: p.shortName, ...dropEmptyWriteRoles(p.options) };
-    return `r.secret(${renderValue(merged)});`;
-}
-function renderSecretNamespace(p) {
-    if (isRawRefSentinel(p.options)) {
-        return `r.secretNamespace(${JSON.stringify(p.shortName)}, ${p.options.__raw});`;
-    }
-    const merged = { name: p.shortName, ...dropEmptyWriteRoles(p.options) };
-    return `r.secretNamespace(${renderValue(merged)});`;
-}
-function renderClaimKey(p) {
-    return `r.claimKey(${renderValue({ name: p.shortName, type: p.claimType })});`;
-}
-function renderReferenceData(p) {
-    const merged = {
-        entity: p.entityName,
-        data: [...p.data],
-        ...(p.upsertKey !== undefined && { upsertKey: p.upsertKey }),
-    };
-    return `r.referenceData(${renderValue(merged)});`;
-}
-function renderUseExtension(p) {
-    const nameLiteral = p.extensionNameRaw ?? JSON.stringify(p.extensionName);
-    if (isRawRefSentinel(p.options)) {
-        return `r.useExtension(${nameLiteral}, ${JSON.stringify(p.entityName)}, ${p.options.__raw});`;
-    }
-    if (p.extensionNameRaw !== undefined) {
-        // A raw-ref name can't be spread into the merged Object-Form without
-        // losing it to renderValue's plain-string serialization — fall back
-        // to positional form, which keeps the reference verbatim.
-        const optionsArg = p.options !== undefined ? `, ${renderValue(p.options)}` : "";
-        return `r.useExtension(${nameLiteral}, ${JSON.stringify(p.entityName)}${optionsArg});`;
-    }
-    const merged = {
-        name: p.extensionName,
-        entity: p.entityName,
-        ...(p.options ?? {}),
-    };
-    return `r.useExtension(${renderValue(merged)});`;
-}
-// =============================================================================
-// Mixed patterns — header is data, body is opaque source-span (raw TS).
-//
-// We embed `SourceLocation.raw` verbatim. The static parts get rendered
-// as JSON-like values; the closure / schema / template body slots in as
-// the original text. Indentation matters for biome-stability — opaque
-// bodies are placed at the property's indent level.
-// =============================================================================
-function renderScreen(p) {
-    // ScreenDefinition may carry $opaque markers where closures lived.
-    // We swap each marker for the raw source span from opaqueProps. Walking
-    // the definition by JSON-path matches how the parser keys the spans.
-    const woven = weaveOpaque(p.definition, p.opaqueProps, "");
-    return `r.screen(${renderValueWithRawSlots(woven, 0)});`;
-}
-/**
- * Re-indent a multi-line opaque source span so its continuation lines
- * align with the new context. The body's first line is left as-is (it's
- * inserted right after `: ` in the property assignment); follow-up
- * lines have their *minimum leading whitespace* stripped, then the new
- * indent prepended. Single-line bodies pass through.
- *
- * Why: bodies are captured verbatim from the original file at whatever
- * indent they sat at. When embedded into a different surrounding
- * structure (e.g. positional → object form), the relative indent
- * shifts. Without this normalisation the rendered output looks ragged
- * and the roundtrip equality test sees `raw` strings that differ in
- * whitespace, even though the code is identical.
- */
-function reindentBody(raw, newIndent) {
-    const lines = raw.split("\n");
-    if (lines.length <= 1)
-        return raw;
-    // Determine the smallest leading-whitespace of non-empty continuation lines.
-    let minIndent = Infinity;
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (line === undefined)
-            continue;
-        if (line.trim() === "")
-            continue;
-        const lead = line.match(/^[ \t]*/)?.[0].length ?? 0;
-        if (lead < minIndent)
-            minIndent = lead;
-    }
-    if (!Number.isFinite(minIndent))
-        return raw;
-    const out = [lines[0] ?? ""];
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i] ?? "";
-        if (line.trim() === "") {
-            out.push("");
-        }
-        else {
-            out.push(newIndent + line.slice(minIndent));
-        }
-    }
-    return out.join("\n");
-}
-function renderWriteHandler(p) {
-    if (p.handlerName === undefined)
-        return p.source.raw;
-    const lines = ["r.writeHandler({"];
-    lines.push(`  name: ${JSON.stringify(p.handlerName)},`);
-    lines.push(`  schema: ${reindentBody(p.schemaSource?.raw ?? "", PATTERN_INDENT)},`);
-    lines.push(`  handler: ${reindentBody(p.handlerBody?.raw ?? "", PATTERN_INDENT)},`);
-    if (p.access !== undefined)
-        lines.push(`  access: ${renderValue(p.access)},`);
-    if (p.description !== undefined)
-        lines.push(`  description: ${JSON.stringify(p.description)},`);
-    if (p.agent !== undefined)
-        lines.push(`  agent: ${renderValue(p.agent)},`);
-    if (p.rateLimit !== undefined)
-        lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
-    if (p.additionalRateLimits !== undefined) {
-        lines.push(`  additionalRateLimits: ${renderValue(p.additionalRateLimits)},`);
-    }
-    if (p.unsafeSkipTransitionGuard === true)
-        lines.push("  unsafeSkipTransitionGuard: true,");
-    if (p.escapeHatch !== undefined)
-        lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderQueryHandler(p) {
-    if (p.handlerName === undefined)
-        return p.source.raw;
-    const lines = ["r.queryHandler({"];
-    lines.push(`  name: ${JSON.stringify(p.handlerName)},`);
-    lines.push(`  schema: ${reindentBody(p.schemaSource?.raw ?? "", PATTERN_INDENT)},`);
-    lines.push(`  handler: ${reindentBody(p.handlerBody?.raw ?? "", PATTERN_INDENT)},`);
-    if (p.access !== undefined)
-        lines.push(`  access: ${renderValue(p.access)},`);
-    if (p.description !== undefined)
-        lines.push(`  description: ${JSON.stringify(p.description)},`);
-    if (p.agent !== undefined)
-        lines.push(`  agent: ${renderValue(p.agent)},`);
-    if (p.rateLimit !== undefined)
-        lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
-    if (p.escapeHatch !== undefined)
-        lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderStreamHandler(p) {
-    if (p.handlerName === undefined)
-        return p.source.raw;
-    const lines = ["r.streamHandler({"];
-    lines.push(`  name: ${JSON.stringify(p.handlerName)},`);
-    lines.push(`  schema: ${reindentBody(p.schemaSource?.raw ?? "", PATTERN_INDENT)},`);
-    lines.push(`  handler: ${reindentBody(p.handlerBody?.raw ?? "", PATTERN_INDENT)},`);
-    if (p.access !== undefined)
-        lines.push(`  access: ${renderValue(p.access)},`);
-    if (p.rateLimit !== undefined)
-        lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
-    if (p.escapeHatch !== undefined)
-        lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderHookTarget(target) {
-    if (typeof target === "string")
-        return renderValue(target);
-    if ("allOf" in target)
-        return `{ allOf: ${JSON.stringify(target.allOf)} }`;
-    return renderValue([...target]);
-}
-function renderHook(p) {
-    const lines = ["r.hook({"];
-    lines.push(`  type: ${JSON.stringify(p.hookType)},`);
-    lines.push(`  target: ${renderHookTarget(p.target)},`);
-    lines.push(`  handler: ${reindentBody(p.fnBody.raw, PATTERN_INDENT)},`);
-    if (p.phase !== undefined)
-        lines.push(`  phase: ${JSON.stringify(p.phase)},`);
-    if (p.escapeHatch !== undefined)
-        lines.push(`  escapeHatch: ${renderValue(p.escapeHatch)},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderEditableString(value) {
-    return typeof value === "string" ? JSON.stringify(value) : value.__raw;
-}
-function renderEditableDefaults(value) {
-    if (isRawRefSentinel(value))
-        return value.__raw;
-    return renderValue(value);
-}
-function renderAiStepCommonFields(lines, p) {
-    if (p.stepKey !== undefined)
-        lines.push(`  stepKey: ${renderEditableString(p.stepKey)},`);
-    if (p.promptKey !== undefined)
-        lines.push(`  promptKey: ${renderEditableString(p.promptKey)},`);
-    if (p.promptFallback !== undefined) {
-        lines.push(`  promptFallback: ${renderEditableString(p.promptFallback)},`);
-    }
-    if (p.paramsSchemaSource !== undefined) {
-        lines.push(`  paramsSchema: ${p.paramsSchemaSource.raw},`);
-    }
-    if (p.defaults !== undefined) {
-        lines.push(`  defaults: ${renderEditableDefaults(p.defaults)},`);
-    }
-}
-function renderAiGenerate(p) {
-    if (p.argsSource)
-        return `aiGenerateStep(${p.argsSource.__raw})`;
-    const lines = ["aiGenerateStep({"];
-    renderAiStepCommonFields(lines, p);
-    if (p.inputBody !== undefined)
-        lines.push(`  input: ${p.inputBody.raw},`);
-    lines.push("})");
-    return lines.join("\n");
-}
-function renderAiExtract(p) {
-    if (p.argsSource)
-        return `aiExtractStep(${p.argsSource.__raw})`;
-    const lines = ["aiExtractStep({"];
-    renderAiStepCommonFields(lines, p);
-    if (p.outputSchemaSource !== undefined) {
-        lines.push(`  outputSchema: ${p.outputSchemaSource.raw},`);
-    }
-    if (p.instructionsBody !== undefined) {
-        lines.push(`  instructions: ${p.instructionsBody.raw},`);
-    }
-    if (p.documentBody !== undefined)
-        lines.push(`  document: ${p.documentBody.raw},`);
-    lines.push("})");
-    return lines.join("\n");
-}
-function renderAiClassify(p) {
-    if (p.argsSource)
-        return `aiClassifyStep(${p.argsSource.__raw})`;
-    const lines = ["aiClassifyStep({"];
-    renderAiStepCommonFields(lines, p);
-    if (p.actions !== undefined)
-        lines.push(`  actions: ${renderValue(p.actions)},`);
-    if (p.inputBody !== undefined)
-        lines.push(`  input: ${p.inputBody.raw},`);
-    lines.push("})");
-    return lines.join("\n");
-}
-function renderJob(p) {
-    const lines = ["r.job({"];
-    lines.push(`  name: ${JSON.stringify(p.jobName)},`);
-    for (const [k, v] of Object.entries(p.options)) {
-        lines.push(`  ${renderKey(k)}: ${renderValue(v)},`);
-    }
-    lines.push(`  handler: ${p.handlerBody.raw},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderNotification(p) {
-    const lines = ["r.notification({"];
-    lines.push(`  name: ${JSON.stringify(p.notificationName)},`);
-    if (p.trigger)
-        lines.push(`  trigger: { on: ${JSON.stringify(p.trigger.on)} },`);
-    if (p.recipientBody)
-        lines.push(`  recipient: ${p.recipientBody.raw},`);
-    if (p.dataBody)
-        lines.push(`  data: ${p.dataBody.raw},`);
-    if (p.templates && Object.keys(p.templates).length > 0) {
-        lines.push("  templates: {");
-        for (const [k, loc] of Object.entries(p.templates)) {
-            lines.push(`    ${renderKey(k)}: ${loc.raw},`);
-        }
-        lines.push("  },");
-    }
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderAuthClaims(p) {
-    return `r.authClaims(${p.fnBody.raw});`;
-}
-// treeActions is a static object-literal (mirrors renderWorkspace).
-function renderTreeActions(p) {
-    return `r.treeActions(${renderValue(p.definitions)});`;
-}
-function renderHttpRoute(p) {
-    const lines = ["r.httpRoute({"];
-    lines.push(`  method: ${JSON.stringify(p.method)},`);
-    lines.push(`  path: ${JSON.stringify(p.path)},`);
-    lines.push(`  anonymous: ${p.anonymous},`);
-    lines.push(`  handler: ${p.handlerBody.raw},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderProjection(p) {
-    const lines = ["r.projection({"];
-    lines.push(`  name: ${JSON.stringify(p.name)},`);
-    // ProjectionPattern.sourceEntity is the typed field; the runtime
-    // r.projection({...}) call uses `source` (matches ProjectionDefinition).
-    lines.push(`  source: ${renderValue(typeof p.sourceEntity === "string" ? p.sourceEntity : [...p.sourceEntity])},`);
-    lines.push("  apply: {");
-    for (const [eventType, loc] of Object.entries(p.applyBodies)) {
-        lines.push(`    ${renderKey(eventType)}: ${loc.raw},`);
-    }
-    lines.push("  },");
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderMultiStreamProjection(p) {
-    const lines = ["r.multiStreamProjection({"];
-    lines.push(`  name: ${JSON.stringify(p.name)},`);
-    lines.push("  apply: {");
-    for (const [eventType, loc] of Object.entries(p.applyBodies)) {
-        lines.push(`    ${renderKey(eventType)}: ${loc.raw},`);
-    }
-    lines.push("  },");
-    if (p.errorMode !== undefined)
-        lines.push(`  errorMode: ${renderValue(p.errorMode)},`);
-    if (p.runIn !== undefined)
-        lines.push(`  runIn: ${renderValue(p.runIn)},`);
-    if (p.delivery !== undefined)
-        lines.push(`  delivery: ${JSON.stringify(p.delivery)},`);
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderDefineEvent(p) {
-    const nameLiteral = p.eventNameRaw ?? JSON.stringify(p.eventName);
-    const migrationEntries = p.migrations !== undefined ? Object.entries(p.migrations) : [];
-    // piiFields is a mandatory option — the options object is
-    // always rendered, unlike the old version/migrations-only shortcut.
-    const lines = [`r.defineEvent(${nameLiteral}, ${p.schemaSource.raw}, {`];
-    lines.push(`  piiFields: ${p.piiFields.raw},`);
-    if (p.version !== undefined)
-        lines.push(`  version: ${p.version},`);
-    if (migrationEntries.length > 0) {
-        lines.push("  migrations: [");
-        for (const [fromVersion, transformBody] of migrationEntries) {
-            const from = Number(fromVersion);
-            lines.push(`    { fromVersion: ${from}, toVersion: ${from + 1}, transform: ${transformBody.raw} },`);
-        }
-        lines.push("  ],");
-    }
-    lines.push("});");
-    return lines.join("\n");
-}
-function renderExtendsRegistrar(p) {
-    const nameLiteral = p.extensionNameRaw ?? JSON.stringify(p.extensionName);
-    return `r.extendsRegistrar(${nameLiteral}, ${p.defBody.raw});`;
-}
-function renderEnvSchema(p) {
-    return `r.envSchema(${p.schemaBody.raw});`;
-}
-function renderUsesApi(p) {
-    return `r.usesApi(${JSON.stringify(p.apiName)});`;
-}
-function renderExposesApi(p) {
-    return `r.exposesApi(${JSON.stringify(p.apiName)});`;
-}
-function renderUiHints(p) {
-    return p.source.raw;
-}
-function renderUnknown(p) {
-    // Round-trip preservation only: emit the raw call text from the
-    // SourceLocation so the rendered file stays semantically identical
-    // to the input.
-    //
-    // **Patch-Surprise warning:** an UnknownPattern cannot be added via
-    // FeaturePatcher (no typed `addUnknown` exists, by design — typed
-    // adds force the caller to commit to a known pattern-kind). It also
-    // cannot be replaced/removed cleanly, because no PatternId variant
-    // matches an UnknownPattern's free-form shape. Treat UnknownPattern
-    // as read-only in the patcher pipeline; the only way to "edit" one
-    // is to convert it to a known pattern-kind first (i.e. add a typed
-    // extractor + pattern type).
-    return p.source.raw;
-}
-function weaveOpaque(value, opaqueProps, path) {
-    if (value === SCREEN_OPAQUE_MARKER) {
-        const span = opaqueProps[path];
-        if (!span)
-            throw new Error(`weaveOpaque: missing span for path "${path}"`);
-        return { __raw: span.raw };
-    }
-    if (Array.isArray(value)) {
-        return value.map((el, idx) => weaveOpaque(el, opaqueProps, `${path}.${idx}`));
-    }
-    if (value && typeof value === "object") {
-        const out = {};
-        for (const [k, v] of Object.entries(value)) {
-            const childPath = path ? `${path}.${k}` : k;
-            out[k] = weaveOpaque(v, opaqueProps, childPath);
-        }
-        return out;
-    }
-    return value;
-}
-function renderValueWithRawSlots(value, indent) {
-    if (isRawRefSentinel(value))
-        return value.__raw;
-    if (Array.isArray(value)) {
-        if (value.length === 0)
-            return "[]";
-        const inner = value
-            .map((v) => `${spaces(indent + 2)}${renderValueWithRawSlots(v, indent + 2)}`)
-            .join(",\n");
-        return `[\n${inner},\n${spaces(indent)}]`;
-    }
-    if (value !== null && typeof value === "object") {
-        const entries = Object.entries(value);
-        if (entries.length === 0)
-            return "{}";
-        const inner = entries
-            .map(([k, v]) => `${spaces(indent + 2)}${renderKey(k)}: ${renderValueWithRawSlots(v, indent + 2)}`)
-            .join(",\n");
-        return `{\n${inner},\n${spaces(indent)}}`;
-    }
-    return renderValue(value, indent);
-}
-const DEFAULT_IMPORTS = [
-    'import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";',
-    'import * as z from "zod";',
-];
-/**
- * Render a complete feature-file: schema-version header, imports, the
- * defineFeature call wrapping every pattern in source order. The output
- * is biome-format-stable so callers can persist it directly.
- */
-export function renderFeatureFile(input) {
-    const imports = input.imports ?? DEFAULT_IMPORTS;
-    const body = input.patterns.map((p) => indent(renderPattern(p), PATTERN_INDENT)).join("\n\n");
-    return [
-        VERSION_HEADER,
-        "",
-        ...imports,
-        "",
-        `defineFeature(${JSON.stringify(input.featureName)}, (r) => {`,
-        body,
-        "});",
-        "",
-    ].join("\n");
-}
-/**
- * Prefix every non-empty line of `text` with `prefix`. Re-used from the
- * patcher (patch.ts imports this) so indent helpers stay in one place
- * — when canonical-form indentation conventions ever change, only this
- * function needs to follow.
- */
-export function indent(text, prefix) {
-    return text
-        .split("\n")
-        .map((line) => (line.length === 0 ? line : prefix + line))
-        .join("\n");
-}
-/**
- * Indentation prefix used inside `defineFeature((r) => { ... })` for
- * every top-level r.* statement. Two-space convention matches biome's
- * default and the parse-happy-path test fixture.
- */
-export const PATTERN_INDENT = "  ";

package/dist/engine/feature-ast/source-location.d.ts

@@ -1,17 +0,0 @@
-import type { Node, SourceFile } from "ts-morph";
-export type SourcePosition = {
-    readonly line: number;
-    readonly column: number;
-};
-export type SourceLocation = {
-    readonly file: string;
-    readonly start: SourcePosition;
-    readonly end: SourcePosition;
-    readonly raw: string;
-};
-/**
- * Build a SourceLocation from a ts-morph Node. Lives here (not in
- * parse.ts) so extractors can use it without importing parse.ts —
- * keeps the dependency graph one-way.
- */
-export declare function sourceLocationFromNode(node: Node, sourceFile: SourceFile): SourceLocation;