@cosmicdrift/kumiko-framework 0.389.0 → 0.390.1

package/dist/engine/feature-ast/extractors/round2.js

@@ -1,191 +0,0 @@
-import { SyntaxKind } from "ts-morph";
-import { describeUnknownFieldType, findUnknownEntityFieldTypes } from "../entity-field-types.js";
-import { sourceLocationFromNode } from "../source-location.js";
-import { fail, isPlainObject, isRawRefSentinel, ok, readDataLiteralNode, readNameLiteral, readNameOrRef, } from "./shared.js";
-function readBackingTableRef(property) {
-    const initializer = property.asKind(SyntaxKind.PropertyAssignment)?.getInitializer() ??
-        property.asKind(SyntaxKind.ShorthandPropertyAssignment)?.getNameNode();
-    const reference = initializer ? readDataLiteralNode(initializer) : undefined;
-    return isRawRefSentinel(reference) ? reference : undefined;
-}
-// `{ name: "x", ...xEntity }` — the definition is a reference the parser cannot
-// inline, so it is kept as a raw-ref sentinel and re-rendered as the same spread.
-// `backingTable` is runtime wiring (a table identifier), not part of the
-// definition data, so it is carried next to the definition and skipped by the shape check.
-function readSpreadOnlyDefinition(obj) {
-    const isBackingTable = (property) => {
-        const name = property.asKind(SyntaxKind.PropertyAssignment)?.getName() ??
-            property.asKind(SyntaxKind.ShorthandPropertyAssignment)?.getName();
-        return name === "backingTable";
-    };
-    const allProperties = obj.getProperties();
-    const properties = allProperties.filter((property) => !isBackingTable(property));
-    const spread = properties.length === 2 ? properties[1]?.asKind(SyntaxKind.SpreadAssignment) : undefined;
-    if (!spread)
-        return undefined;
-    const reference = readDataLiteralNode(spread.getExpression());
-    if (!isRawRefSentinel(reference))
-        return undefined;
-    const backingTableProperty = allProperties.find(isBackingTable);
-    const backingTable = backingTableProperty ? readBackingTableRef(backingTableProperty) : undefined;
-    // A backingTable that is not a plain reference cannot be re-rendered; fall back to the data reader.
-    if (backingTableProperty && !backingTable)
-        return undefined;
-    return { definition: reference, backingTable };
-}
-export function extractEntity(call, sourceFile) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail("entity", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj && args.length === 1) {
-        const nameInit = obj
-            .getProperty("name")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (!nameInit) {
-            return fail("entity", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
-        }
-        const spreadOnly = readSpreadOnlyDefinition(obj);
-        const definition = spreadOnly?.definition ?? readDataLiteralNode(obj);
-        if (!isPlainObject(definition)) {
-            return fail("entity", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object (contains functions or identifiers)");
-        }
-        const { name: _name, ...defWithoutName } = definition;
-        const unknownTypes = findUnknownEntityFieldTypes(defWithoutName);
-        const firstUnknown = unknownTypes[0];
-        if (firstUnknown) {
-            return fail("entity", sourceLocationFromNode(call, sourceFile), `definition.fields.${firstUnknown.fieldName}.type: ${describeUnknownFieldType(firstUnknown)}`);
-        }
-        return ok({
-            kind: "entity",
-            source: sourceLocationFromNode(call, sourceFile),
-            entityName: nameInit.getLiteralValue(),
-            // Field-type membership is checked above; the cast is the extractor's
-            // existing narrowing contract (readDataLiteralNode returns unknown).
-            definition: defWithoutName,
-            ...(spreadOnly?.backingTable && { backingTable: spreadOnly.backingTable }),
-        });
-    }
-    const entityName = readNameLiteral(first);
-    if (entityName === undefined) {
-        return fail("entity", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal name, or an identifier resolving to one (or use the object form)");
-    }
-    const defArg = args[1];
-    if (!defArg) {
-        return fail("entity", sourceLocationFromNode(call, sourceFile), "expected a definition object as second argument");
-    }
-    const definition = readDataLiteralNode(defArg);
-    if (!isPlainObject(definition)) {
-        return fail("entity", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object (contains functions or identifiers)");
-    }
-    const unknownTypes = findUnknownEntityFieldTypes(definition);
-    const firstUnknown = unknownTypes[0];
-    if (firstUnknown) {
-        return fail("entity", sourceLocationFromNode(call, sourceFile), `definition.fields.${firstUnknown.fieldName}.type: ${describeUnknownFieldType(firstUnknown)}`);
-    }
-    return ok({
-        kind: "entity",
-        source: sourceLocationFromNode(call, sourceFile),
-        entityName,
-        definition: definition,
-    });
-}
-export function extractRelation(call, sourceFile) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail("relation", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj && args.length === 1) {
-        const entityInit = obj
-            .getProperty("entity")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!entityInit) {
-            return fail("relation", sourceLocationFromNode(call, sourceFile), "object form requires an `entity` property");
-        }
-        const entityName = readNameOrRef(entityInit);
-        if (!entityName) {
-            return fail("relation", sourceLocationFromNode(call, sourceFile), '`entity` must be a string literal or `{ name: "..." }` ref');
-        }
-        const nameInit = obj
-            .getProperty("name")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (!nameInit) {
-            return fail("relation", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
-        }
-        const definition = readDataLiteralNode(obj);
-        if (!isPlainObject(definition)) {
-            return fail("relation", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
-        }
-        const { entity: _e, name: _n, ...defWithoutCarriers } = definition;
-        return ok({
-            kind: "relation",
-            source: sourceLocationFromNode(call, sourceFile),
-            entityName,
-            relationName: nameInit.getLiteralValue(),
-            definition: defWithoutCarriers,
-        });
-    }
-    const entityName = readNameOrRef(first);
-    if (!entityName) {
-        return fail("relation", sourceLocationFromNode(call, sourceFile), 'first argument must be a string literal or an inline { name: "..." } object (or use the object form)');
-    }
-    const relationNameArg = args[1];
-    const relationName = relationNameArg && readNameLiteral(relationNameArg);
-    if (!relationName) {
-        return fail("relation", sourceLocationFromNode(call, sourceFile), "second argument must be a string literal relation name, or an identifier resolving to one");
-    }
-    const defArg = args[2];
-    if (!defArg) {
-        return fail("relation", sourceLocationFromNode(call, sourceFile), "expected a definition object as third argument");
-    }
-    const definition = readDataLiteralNode(defArg);
-    if (!isPlainObject(definition)) {
-        return fail("relation", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
-    }
-    return ok({
-        kind: "relation",
-        source: sourceLocationFromNode(call, sourceFile),
-        entityName,
-        relationName,
-        definition: definition,
-    });
-}
-export function extractNav(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("nav", sourceLocationFromNode(call, sourceFile), "expected a NavDefinition object as first argument");
-    }
-    const definition = readDataLiteralNode(arg);
-    if (!isPlainObject(definition)) {
-        return fail("nav", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
-    }
-    return ok({
-        kind: "nav",
-        source: sourceLocationFromNode(call, sourceFile),
-        definition: definition,
-    });
-}
-export function extractWorkspace(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("workspace", sourceLocationFromNode(call, sourceFile), "expected a WorkspaceDefinition object as first argument");
-    }
-    const definition = readDataLiteralNode(arg);
-    if (!isPlainObject(definition)) {
-        return fail("workspace", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
-    }
-    return ok({
-        kind: "workspace",
-        source: sourceLocationFromNode(call, sourceFile),
-        definition: definition,
-    });
-}

package/dist/engine/feature-ast/extractors/round3.d.ts

@@ -1,23 +0,0 @@
-import type { CallExpression, SourceFile } from "ts-morph";
-import type { ClaimKeyType } from "../../types/handlers.ts";
-import type { ParseError } from "../parse.ts";
-import type { ClaimKeyPattern, ConfigPattern, MetricPattern, ReferenceDataPattern, SecretNamespacePattern, SecretPattern, TranslationsPattern, UseExtensionPattern } from "../patterns.ts";
-import { type ExtractOutput, type ReadDataLiteralOptions } from "./shared.ts";
-export type NamedOptionsResult = {
-    readonly kind: "ok";
-    readonly name: string;
-    readonly options: Record<string, unknown>;
-} | {
-    readonly kind: "error";
-    readonly error: ParseError;
-};
-export declare function readNamedOptions(call: CallExpression, sourceFile: SourceFile, methodName: string, readOptions?: ReadDataLiteralOptions): NamedOptionsResult;
-export declare function extractConfig(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ConfigPattern>;
-export declare function extractTranslations(call: CallExpression, sourceFile: SourceFile): ExtractOutput<TranslationsPattern>;
-export declare function extractMetric(call: CallExpression, sourceFile: SourceFile): ExtractOutput<MetricPattern>;
-export declare function extractSecret(call: CallExpression, sourceFile: SourceFile): ExtractOutput<SecretPattern>;
-export declare function extractSecretNamespace(call: CallExpression, sourceFile: SourceFile): ExtractOutput<SecretNamespacePattern>;
-export declare function isClaimKeyType(value: unknown): value is ClaimKeyType;
-export declare function extractClaimKey(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ClaimKeyPattern>;
-export declare function extractReferenceData(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ReferenceDataPattern>;
-export declare function extractUseExtension(call: CallExpression, sourceFile: SourceFile): ExtractOutput<UseExtensionPattern>;

package/dist/engine/feature-ast/extractors/round3.js

@@ -1,292 +0,0 @@
-import { SyntaxKind } from "ts-morph";
-import { sourceLocationFromNode } from "../source-location.js";
-import { fail, isPlainObject, ok, readDataLiteralNode, readNameLiteral, readNameLiteralRef, readNameOrRef, } from "./shared.js";
-export function readNamedOptions(call, sourceFile, methodName, readOptions = {}) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj && args.length === 1) {
-        const nameInit = obj
-            .getProperty("name")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (!nameInit) {
-            return fail(methodName, sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
-        }
-        const data = readDataLiteralNode(obj, readOptions);
-        if (!isPlainObject(data)) {
-            return fail(methodName, sourceLocationFromNode(call, sourceFile), "argument could not be read as a plain object");
-        }
-        const { name: _name, ...optionsWithoutName } = data;
-        return { kind: "ok", name: nameInit.getLiteralValue(), options: optionsWithoutName };
-    }
-    const name = readNameLiteral(first);
-    if (name === undefined) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "first argument must be a string literal name, or an identifier resolving to one (or use the object form)");
-    }
-    const optionsArg = args[1];
-    if (!optionsArg) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected an options object as second argument");
-    }
-    const options = readDataLiteralNode(optionsArg, readOptions);
-    if (!isPlainObject(options)) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
-    }
-    return { kind: "ok", name, options };
-}
-export function extractConfig(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("config", sourceLocationFromNode(call, sourceFile), "expected `{ keys: { ... } }` as first argument");
-    }
-    const obj = readDataLiteralNode(arg);
-    if (!isPlainObject(obj)) {
-        return fail("config", sourceLocationFromNode(call, sourceFile), "argument could not be read as a plain object");
-    }
-    const keys = obj["keys"];
-    if (!isPlainObject(keys)) {
-        return fail("config", sourceLocationFromNode(call, sourceFile), "missing or non-object `keys` property");
-    }
-    return ok({
-        kind: "config",
-        source: sourceLocationFromNode(call, sourceFile),
-        keys: keys,
-    });
-}
-export function extractTranslations(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("translations", sourceLocationFromNode(call, sourceFile), "expected `{ keys: { ... } }` as first argument");
-    }
-    const obj = readDataLiteralNode(arg);
-    if (!isPlainObject(obj)) {
-        return fail("translations", sourceLocationFromNode(call, sourceFile), "argument could not be read as a plain object");
-    }
-    const keys = obj["keys"];
-    if (!isPlainObject(keys)) {
-        return fail("translations", sourceLocationFromNode(call, sourceFile), "missing or non-object `keys` property");
-    }
-    return ok({
-        kind: "translations",
-        source: sourceLocationFromNode(call, sourceFile),
-        keys: keys,
-    });
-}
-export function extractMetric(call, sourceFile) {
-    const parsed = readNamedOptions(call, sourceFile, "metric");
-    if (parsed.kind === "error")
-        return parsed;
-    return ok({
-        kind: "metric",
-        source: sourceLocationFromNode(call, sourceFile),
-        shortName: parsed.name,
-        options: parsed.options,
-    });
-}
-export function extractSecret(call, sourceFile) {
-    const parsed = readNamedOptions(call, sourceFile, "secret", { functionValuesAsRaw: true });
-    if (parsed.kind === "error")
-        return parsed;
-    return ok({
-        kind: "secret",
-        source: sourceLocationFromNode(call, sourceFile),
-        shortName: parsed.name,
-        options: parsed.options,
-    });
-}
-export function extractSecretNamespace(call, sourceFile) {
-    const parsed = readNamedOptions(call, sourceFile, "secretNamespace");
-    if (parsed.kind === "error")
-        return parsed;
-    return ok({
-        kind: "secretNamespace",
-        source: sourceLocationFromNode(call, sourceFile),
-        shortName: parsed.name,
-        options: parsed.options,
-    });
-}
-export function isClaimKeyType(value) {
-    return (value === "string" ||
-        value === "number" ||
-        value === "boolean" ||
-        value === "string[]" ||
-        value === "object");
-}
-export function extractClaimKey(call, sourceFile) {
-    const parsed = readNamedOptions(call, sourceFile, "claimKey");
-    if (parsed.kind === "error")
-        return parsed;
-    const claimType = parsed.options["type"];
-    if (!isClaimKeyType(claimType)) {
-        return fail("claimKey", sourceLocationFromNode(call, sourceFile), 'type must be one of "string" | "number" | "boolean" | "string[]" | "object"');
-    }
-    return ok({
-        kind: "claimKey",
-        source: sourceLocationFromNode(call, sourceFile),
-        shortName: parsed.name,
-        claimType,
-    });
-}
-export function extractReferenceData(call, sourceFile) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail("referenceData", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj && args.length === 1) {
-        const entityInit = obj
-            .getProperty("entity")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!entityInit) {
-            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "object form requires an `entity` property");
-        }
-        const entityName = readNameOrRef(entityInit);
-        if (!entityName) {
-            return fail("referenceData", sourceLocationFromNode(call, sourceFile), '`entity` must be a string literal or `{ name: "..." }` ref');
-        }
-        const dataInit = obj
-            .getProperty("data")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!dataInit) {
-            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "object form requires a `data` property");
-        }
-        const data = readDataLiteralNode(dataInit);
-        if (!Array.isArray(data) || !data.every(isPlainObject)) {
-            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "data must be an array of plain objects");
-        }
-        let upsertKey;
-        const upsertKeyInit = obj
-            .getProperty("upsertKey")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (upsertKeyInit) {
-            upsertKey = upsertKeyInit.getLiteralValue();
-        }
-        return ok({
-            kind: "referenceData",
-            source: sourceLocationFromNode(call, sourceFile),
-            entityName,
-            data: data,
-            ...(upsertKey !== undefined && { upsertKey }),
-        });
-    }
-    const entityName = readNameOrRef(first);
-    if (!entityName) {
-        return fail("referenceData", sourceLocationFromNode(call, sourceFile), 'first argument must be a string literal or an inline { name: "..." } object (or use the object form)');
-    }
-    const dataArg = args[1];
-    if (!dataArg) {
-        return fail("referenceData", sourceLocationFromNode(call, sourceFile), "expected a data array as second argument");
-    }
-    const data = readDataLiteralNode(dataArg);
-    if (!Array.isArray(data) || !data.every(isPlainObject)) {
-        return fail("referenceData", sourceLocationFromNode(call, sourceFile), "data must be an array of plain objects");
-    }
-    let upsertKey;
-    const optionsArg = args[2];
-    if (optionsArg) {
-        const options = readDataLiteralNode(optionsArg);
-        if (!isPlainObject(options)) {
-            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
-        }
-        if (options["upsertKey"] !== undefined) {
-            if (typeof options["upsertKey"] !== "string") {
-                return fail("referenceData", sourceLocationFromNode(call, sourceFile), "upsertKey must be a string when provided");
-            }
-            upsertKey = options["upsertKey"];
-        }
-    }
-    return ok({
-        kind: "referenceData",
-        source: sourceLocationFromNode(call, sourceFile),
-        entityName,
-        data: data,
-        ...(upsertKey !== undefined && { upsertKey }),
-    });
-}
-const USE_EXTENSION_READ_OPTIONS = { functionValuesAsRaw: true };
-export function extractUseExtension(call, sourceFile) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail("useExtension", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj && args.length === 1) {
-        const nameInit = obj
-            .getProperty("name")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (!nameInit) {
-            return fail("useExtension", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
-        }
-        const entityInit = obj
-            .getProperty("entity")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!entityInit) {
-            return fail("useExtension", sourceLocationFromNode(call, sourceFile), "object form requires an `entity` property");
-        }
-        const entityName = readNameOrRef(entityInit);
-        if (!entityName) {
-            return fail("useExtension", sourceLocationFromNode(call, sourceFile), '`entity` must be a string literal or `{ name: "..." }` ref');
-        }
-        let options;
-        const optionsInit = obj
-            .getProperty("options")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (optionsInit) {
-            const parsed = readDataLiteralNode(optionsInit, USE_EXTENSION_READ_OPTIONS);
-            if (!isPlainObject(parsed)) {
-                return fail("useExtension", sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
-            }
-            options = parsed;
-        }
-        return ok({
-            kind: "useExtension",
-            source: sourceLocationFromNode(call, sourceFile),
-            extensionName: nameInit.getLiteralValue(),
-            entityName,
-            ...(options !== undefined && { options }),
-        });
-    }
-    const extensionNameRef = readNameLiteralRef(first);
-    if (extensionNameRef === undefined) {
-        return fail("useExtension", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal extension name, or an identifier resolving to one (or use the object form)");
-    }
-    const entityRefArg = args[1];
-    if (!entityRefArg) {
-        return fail("useExtension", sourceLocationFromNode(call, sourceFile), "expected an entity reference as second argument");
-    }
-    const entityName = readNameOrRef(entityRefArg);
-    if (!entityName) {
-        return fail("useExtension", sourceLocationFromNode(call, sourceFile), 'second argument must be a string literal or an inline { name: "..." } object');
-    }
-    const optionsArg = args[2];
-    let options;
-    if (optionsArg) {
-        const parsed = readDataLiteralNode(optionsArg, USE_EXTENSION_READ_OPTIONS);
-        if (!isPlainObject(parsed)) {
-            return fail("useExtension", sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
-        }
-        options = parsed;
-    }
-    return ok({
-        kind: "useExtension",
-        source: sourceLocationFromNode(call, sourceFile),
-        extensionName: extensionNameRef.value,
-        ...(extensionNameRef.raw !== undefined && { extensionNameRaw: extensionNameRef.raw }),
-        entityName,
-        ...(options !== undefined && { options }),
-    });
-}

package/dist/engine/feature-ast/extractors/round5.d.ts

@@ -1,9 +0,0 @@
-import type { CallExpression, SourceFile } from "ts-morph";
-import type { EnvSchemaPattern, ExposesApiPattern, ExtendsRegistrarPattern, UsesApiPattern } from "../patterns.ts";
-import { type ExtractOutput } from "./shared.ts";
-export declare function extractEnvSchema(call: CallExpression, sourceFile: SourceFile): ExtractOutput<EnvSchemaPattern>;
-export declare function extractExtendsRegistrar(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ExtendsRegistrarPattern>;
-export declare function extractUsesApi(call: CallExpression, sourceFile: SourceFile): ExtractOutput<UsesApiPattern>;
-export declare function extractExposesApi(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ExposesApiPattern>;
-export declare function extractStoreTable(call: CallExpression, sourceFile: SourceFile): ExtractOutput<never>;
-export declare function extractBootCheck(call: CallExpression, sourceFile: SourceFile): ExtractOutput<never>;

package/dist/engine/feature-ast/extractors/round5.js

@@ -1,68 +0,0 @@
-import { sourceLocationFromNode } from "../source-location.js";
-import { fail, ok, readNameLiteral, readNameLiteralRef } from "./shared.js";
-export function extractEnvSchema(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("envSchema", sourceLocationFromNode(call, sourceFile), "expected a single Zod-object schema argument (e.g. z.object({...}))");
-    }
-    return ok({
-        kind: "envSchema",
-        source: sourceLocationFromNode(call, sourceFile),
-        schemaBody: sourceLocationFromNode(arg, sourceFile),
-    });
-}
-export function extractExtendsRegistrar(call, sourceFile) {
-    const args = call.getArguments();
-    const first = args[0];
-    const extensionNameRef = first && readNameLiteralRef(first);
-    if (!extensionNameRef) {
-        return fail("extendsRegistrar", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal extension name, or an identifier resolving to one");
-    }
-    const defArg = args[1];
-    if (!defArg) {
-        return fail("extendsRegistrar", sourceLocationFromNode(call, sourceFile), "expected a definition argument");
-    }
-    return ok({
-        kind: "extendsRegistrar",
-        source: sourceLocationFromNode(call, sourceFile),
-        extensionName: extensionNameRef.value,
-        ...(extensionNameRef.raw !== undefined && { extensionNameRaw: extensionNameRef.raw }),
-        defBody: sourceLocationFromNode(defArg, sourceFile),
-    });
-}
-export function extractUsesApi(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    const apiName = arg && readNameLiteral(arg);
-    if (!apiName) {
-        return fail("usesApi", sourceLocationFromNode(call, sourceFile), 'expected a single string-literal API name (e.g. "sessions.revokeAllForUser"), or an identifier resolving to one');
-    }
-    return ok({
-        kind: "usesApi",
-        source: sourceLocationFromNode(call, sourceFile),
-        apiName,
-    });
-}
-export function extractExposesApi(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    const apiName = arg && readNameLiteral(arg);
-    if (!apiName) {
-        return fail("exposesApi", sourceLocationFromNode(call, sourceFile), 'expected a single string-literal API name (e.g. "sessions.revokeAllForUser"), or an identifier resolving to one');
-    }
-    return ok({
-        kind: "exposesApi",
-        source: sourceLocationFromNode(call, sourceFile),
-        apiName,
-    });
-}
-export function extractStoreTable(call, sourceFile) {
-    // The meta argument is always a factory call (defineUnmanagedTable /
-    // deriveEntityTableMeta) or a captured identifier — never an inline literal,
-    // so there is nothing to extract statically. A clean ParseError (not
-    // UnknownPattern) marks it design-time-unreadable, like entity-by-identifier.
-    return fail("storeTable", sourceLocationFromNode(call, sourceFile), "storeTable meta is a factory/identifier argument, not a static literal");
-}
-export function extractBootCheck(call, sourceFile) {
-    // The argument is a runtime closure over the composed feature list —
-    // nothing to extract statically, so a clean ParseError like storeTable.
-    return fail("bootCheck", sourceLocationFromNode(call, sourceFile), "bootCheck takes a runtime closure, not a static literal");
-}

package/dist/engine/feature-ast/extractors/round6.d.ts

@@ -1,4 +0,0 @@
-import type { CallExpression, SourceFile } from "ts-morph";
-import type { TreeActionsPattern } from "../patterns.ts";
-import { type ExtractOutput } from "./shared.ts";
-export declare function extractTreeActions(call: CallExpression, sourceFile: SourceFile): ExtractOutput<TreeActionsPattern>;

package/dist/engine/feature-ast/extractors/round6.js

@@ -1,17 +0,0 @@
-import { sourceLocationFromNode } from "../source-location.js";
-import { fail, isPlainObject, ok, readDataLiteralNode } from "./shared.js";
-export function extractTreeActions(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("treeActions", sourceLocationFromNode(call, sourceFile), "expected an action-map object literal as first argument");
-    }
-    const definitions = readDataLiteralNode(arg);
-    if (!isPlainObject(definitions)) {
-        return fail("treeActions", sourceLocationFromNode(call, sourceFile), "action-map could not be read as a plain object");
-    }
-    return ok({
-        kind: "treeActions",
-        source: sourceLocationFromNode(call, sourceFile),
-        definitions: definitions,
-    });
-}