@cosmicdrift/kumiko-framework 0.389.0 → 0.390.1

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

@@ -1,358 +0,0 @@
-import { ENTITY_CONVENTION_QUERY_BRAND } from "@cosmicdrift/kumiko-types/handlers";
-import { SyntaxKind } from "ts-morph";
-import { sourceLocationFromNode } from "../source-location.js";
-import { readHeaderValueOrRaw, readOptionalAccessRule, readOptionalAdditionalRateLimits, readOptionalEscapeHatch, readOptionalRateLimit, } from "./hooks.js";
-import { fail, findFunctionLiteral, isPlainObject, isRawRefSentinel, ok, readBooleanProperty, readDataLiteralNode, readNameLiteral, readObjectPropertyInitializer, readPropertyKey, } from "./shared.js";
-export const AGENT_RISK_VALUES = ["low", "mid", "high"];
-function isAgentRisk(value) {
-    return typeof value === "string" && AGENT_RISK_VALUES.includes(value);
-}
-export function readOptionalAgentHints(value) {
-    if (!isPlainObject(value))
-        return undefined;
-    const expose = typeof value["expose"] === "boolean" ? value["expose"] : undefined;
-    const risk = isAgentRisk(value["risk"]) ? value["risk"] : undefined;
-    if (expose === undefined && risk === undefined)
-        return undefined;
-    return {
-        ...(expose !== undefined && { expose }),
-        ...(risk !== undefined && { risk }),
-    };
-}
-// Record<keyof Def, ...> instead of a looser map: adding a field to
-// WriteHandlerDef/QueryHandlerDef/StreamHandlerDef without classifying it
-// here is a compile error, not a silent drop on render.
-const WRITE_HANDLER_KEY_KINDS = {
-    name: "modeled",
-    schema: "modeled",
-    handler: "modeled",
-    access: "modeled",
-    description: "modeled",
-    agent: "modeled",
-    excludedFields: "opaque",
-    unsafeSkipTransitionGuard: "modeled",
-    rateLimit: "modeled",
-    additionalRateLimits: "modeled",
-    rateLimitCost: "opaque",
-    escapeHatch: "modeled",
-    tenantlessAnonymous: "opaque",
-    reserveBeforeTransaction: "opaque",
-    beforeTransaction: "opaque",
-    transaction: "opaque",
-    perform: "opaque",
-};
-const QUERY_HANDLER_KEY_KINDS = {
-    name: "modeled",
-    schema: "modeled",
-    handler: "modeled",
-    [ENTITY_CONVENTION_QUERY_BRAND]: "opaque",
-    access: "modeled",
-    description: "modeled",
-    agent: "modeled",
-    rateLimit: "modeled",
-    outputSchema: "opaque",
-    liveEntities: "opaque",
-    escapeHatch: "modeled",
-};
-const STREAM_HANDLER_KEY_KINDS = {
-    name: "modeled",
-    schema: "modeled",
-    handler: "modeled",
-    access: "modeled",
-    rateLimit: "modeled",
-    escapeHatch: "modeled",
-};
-const HANDLER_KEY_KINDS = {
-    writeHandler: WRITE_HANDLER_KEY_KINDS,
-    queryHandler: QUERY_HANDLER_KEY_KINDS,
-    streamHandler: STREAM_HANDLER_KEY_KINDS,
-};
-function lookupClassification(map, key) {
-    return key in map ? map[key] : undefined;
-}
-function isStaticStringNode(node) {
-    const kind = node.getKind();
-    return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
-}
-function isBooleanLiteralNode(node) {
-    const kind = node.getKind();
-    return kind === SyntaxKind.TrueKeyword || kind === SyntaxKind.FalseKeyword;
-}
-// The literal readers below only understand a static string `description` and
-// a true/false `unsafeSkipTransitionGuard`; any other value shape is lossy.
-function hasUnreadableLiteralValue(key, initializer) {
-    if (key === "description")
-        return !(initializer && isStaticStringNode(initializer));
-    if (key === "unsafeSkipTransitionGuard")
-        return !(initializer && isBooleanLiteralNode(initializer));
-    return false;
-}
-function readStaticStringProperty(obj, key) {
-    const initializer = obj.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
-    return (initializer?.asKind(SyntaxKind.StringLiteral) ??
-        initializer?.asKind(SyntaxKind.NoSubstitutionTemplateLiteral))?.getLiteralValue();
-}
-// True when the call's object body/options carry a shape the extractor
-// cannot losslessly model property-by-property (a spread, a method/accessor
-// shorthand, a computed key, or a key outside the classification map above).
-// Callers fall back to the opaque whole-call pattern instead of dropping
-// whatever they can't read.
-function hasUnmodeledShape(obj, methodName) {
-    const keyKinds = HANDLER_KEY_KINDS[methodName];
-    for (const prop of obj.getProperties()) {
-        if (prop.getKind() === SyntaxKind.SpreadAssignment)
-            return true;
-        const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
-        if (propAssign) {
-            if (propAssign.getNameNode().getKind() === SyntaxKind.ComputedPropertyName)
-                return true;
-            const key = readPropertyKey(propAssign);
-            if (lookupClassification(keyKinds, key) !== "modeled")
-                return true;
-            const initializer = propAssign.getInitializer();
-            if (hasUnreadableLiteralValue(key, initializer))
-                return true;
-            continue;
-        }
-        const shorthand = prop.asKind(SyntaxKind.ShorthandPropertyAssignment);
-        if (shorthand) {
-            const key = shorthand.getName();
-            if (lookupClassification(keyKinds, key) !== "modeled")
-                return true;
-            // A shorthand's value is invisible to the literal readers below.
-            if (key === "description" || key === "unsafeSkipTransitionGuard")
-                return true;
-            continue;
-        }
-        return true;
-    }
-    return false;
-}
-/**
- * Resolves an argument standing in for a handler-call's object-form body:
- * either it's already an object literal, or a bare identifier declared
- * locally (same file only) with one as its initializer. Anything else
- * (imported binding, factory call, ...) is not resolvable here.
- */
-function resolveObjectLiteralArg(node) {
-    const direct = node.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (direct)
-        return direct;
-    const identifier = node.asKind(SyntaxKind.Identifier);
-    if (!identifier)
-        return undefined;
-    const varDecl = node.getSourceFile().getVariableDeclaration(identifier.getText());
-    return varDecl?.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression);
-}
-// Deliberately does NOT resolve identifiers (unlike resolveObjectLiteralArg):
-// an options argument authored as a bare reference has no per-property
-// nodes to read, so parseHandlerCall falls back to the opaque whole-call
-// pattern instead of trying to read headers off it.
-function unwrapObjectLiteral(node) {
-    const direct = node.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (direct)
-        return direct;
-    const asExpr = node.asKind(SyntaxKind.AsExpression);
-    if (asExpr)
-        return unwrapObjectLiteral(asExpr.getExpression());
-    const satisfiesExpr = node.asKind(SyntaxKind.SatisfiesExpression);
-    if (satisfiesExpr)
-        return unwrapObjectLiteral(satisfiesExpr.getExpression());
-    const paren = node.asKind(SyntaxKind.ParenthesizedExpression);
-    if (paren)
-        return unwrapObjectLiteral(paren.getExpression());
-    return undefined;
-}
-function readHeaderField(init, recognize, methodName, sourceFile, unrecognizedReason) {
-    if (!init)
-        return ok(undefined);
-    const result = readHeaderValueOrRaw(init, recognize);
-    if (result.kind === "value")
-        return ok(result.value);
-    if (result.kind === "raw")
-        return ok(result.sentinel);
-    return fail(methodName, sourceLocationFromNode(init, sourceFile), unrecognizedReason);
-}
-// Shared by the object-form call body and the positional options object,
-// which carry the same header shape.
-function readHandlerHeaderFields(obj, methodName, sourceFile) {
-    const accessResult = readHeaderField(readObjectPropertyInitializer(obj, "access"), readOptionalAccessRule, methodName, sourceFile, "access must be a recognized AccessRule ({ roles: [...] } or { openToAll: { reason } }), or a reference to one");
-    if (accessResult.kind === "error")
-        return accessResult;
-    const rateLimitResult = readHeaderField(readObjectPropertyInitializer(obj, "rateLimit"), readOptionalRateLimit, methodName, sourceFile, "rateLimit must be { per, limit, windowSeconds }, a non-empty list of those, or { disabled: true, reason }, or a reference to one");
-    if (rateLimitResult.kind === "error")
-        return rateLimitResult;
-    const additionalRateLimitsResult = readHeaderField(readObjectPropertyInitializer(obj, "additionalRateLimits"), readOptionalAdditionalRateLimits, methodName, sourceFile, "additionalRateLimits must be an array of { per: { payloadField }, limit, windowSeconds }, or a reference to one");
-    if (additionalRateLimitsResult.kind === "error")
-        return additionalRateLimitsResult;
-    const escapeHatchResult = readHeaderField(readObjectPropertyInitializer(obj, "escapeHatch"), readOptionalEscapeHatch, methodName, sourceFile, "escapeHatch must be { reason: string }, or a reference to one");
-    if (escapeHatchResult.kind === "error")
-        return escapeHatchResult;
-    const agentResult = readHeaderField(readObjectPropertyInitializer(obj, "agent"), readOptionalAgentHints, methodName, sourceFile, 'agent must be { expose?: boolean, risk?: "low" | "mid" | "high" }, or a reference to one');
-    if (agentResult.kind === "error")
-        return agentResult;
-    return ok({
-        ...(accessResult.pattern !== undefined && { access: accessResult.pattern }),
-        ...(rateLimitResult.pattern !== undefined && { rateLimit: rateLimitResult.pattern }),
-        ...(additionalRateLimitsResult.pattern !== undefined && {
-            additionalRateLimits: additionalRateLimitsResult.pattern,
-        }),
-        ...(escapeHatchResult.pattern !== undefined && { escapeHatch: escapeHatchResult.pattern }),
-        ...(agentResult.pattern !== undefined && { agent: agentResult.pattern }),
-    });
-}
-export function parseHandlerCall(call, sourceFile, methodName) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = args.length === 1 ? resolveObjectLiteralArg(first) : undefined;
-    if (obj) {
-        if (hasUnmodeledShape(obj, methodName)) {
-            return ok({ source: sourceLocationFromNode(call, sourceFile) });
-        }
-        const nameLiteral = obj
-            .getProperty("name")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (!nameLiteral) {
-            return fail(methodName, sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
-        }
-        const schemaInit = obj
-            .getProperty("schema")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!schemaInit) {
-            return fail(methodName, sourceLocationFromNode(call, sourceFile), "object form requires a `schema` property");
-        }
-        const handlerInit = obj
-            .getProperty("handler")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!handlerInit) {
-            return fail(methodName, sourceLocationFromNode(call, sourceFile), "object form requires a `handler` property");
-        }
-        const fn = findFunctionLiteral(handlerInit);
-        if (!fn) {
-            return fail(methodName, sourceLocationFromNode(call, sourceFile), "handler must be an inline arrow function or function expression");
-        }
-        const headerResult = readHandlerHeaderFields(obj, methodName, sourceFile);
-        if (headerResult.kind === "error")
-            return headerResult;
-        const description = readStaticStringProperty(obj, "description");
-        const skip = readBooleanProperty(obj, "unsafeSkipTransitionGuard");
-        return ok({
-            source: sourceLocationFromNode(call, sourceFile),
-            handlerName: nameLiteral.getLiteralValue(),
-            schemaSource: sourceLocationFromNode(schemaInit, sourceFile),
-            handlerBody: sourceLocationFromNode(fn, sourceFile),
-            ...headerResult.pattern,
-            ...(description !== undefined && { description }),
-            ...(skip === true && { unsafeSkipTransitionGuard: true }),
-        });
-    }
-    // A single reference standing in for the whole handler argument set
-    // (`r.writeHandler(eventCreateHandler)`, `r.queryHandler(someQuery())`)
-    // that resolveObjectLiteralArg above couldn't turn into an object literal
-    // (imported binding, factory call, ...). Keep it recognised as this kind
-    // instead of ParseErroring. Opaque: renderWriteHandler/
-    // renderQueryHandler re-emit `source.raw` verbatim when handlerName is
-    // undefined.
-    if (args.length === 1 && isRawRefSentinel(readDataLiteralNode(first))) {
-        return ok({ source: sourceLocationFromNode(call, sourceFile) });
-    }
-    const handlerName = readNameLiteral(first);
-    if (handlerName === undefined) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "first argument must be a string literal handler name, or an identifier resolving to one (or use the object form)");
-    }
-    const schemaArg = args[1];
-    if (!schemaArg) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected a Zod schema as second argument");
-    }
-    const handlerArg = args[2];
-    if (!handlerArg) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected a handler function as third argument");
-    }
-    const fn = findFunctionLiteral(handlerArg);
-    if (!fn) {
-        return fail(methodName, sourceLocationFromNode(call, sourceFile), "third argument must be an inline arrow function or function expression");
-    }
-    const optionsArg = args[3];
-    let headerFields = {};
-    let description;
-    let skipTransitionGuard;
-    if (optionsArg) {
-        const optionsObj = unwrapObjectLiteral(optionsArg);
-        if (!optionsObj || hasUnmodeledShape(optionsObj, methodName)) {
-            return ok({ source: sourceLocationFromNode(call, sourceFile) });
-        }
-        const headerResult = readHandlerHeaderFields(optionsObj, methodName, sourceFile);
-        if (headerResult.kind === "error")
-            return headerResult;
-        headerFields = headerResult.pattern;
-        description = readStaticStringProperty(optionsObj, "description");
-        skipTransitionGuard = readBooleanProperty(optionsObj, "unsafeSkipTransitionGuard");
-    }
-    return ok({
-        source: sourceLocationFromNode(call, sourceFile),
-        handlerName,
-        schemaSource: sourceLocationFromNode(schemaArg, sourceFile),
-        handlerBody: sourceLocationFromNode(fn, sourceFile),
-        ...headerFields,
-        ...(description !== undefined && { description }),
-        ...(skipTransitionGuard === true && { unsafeSkipTransitionGuard: true }),
-    });
-}
-export function extractWriteHandler(call, sourceFile) {
-    const parsed = parseHandlerCall(call, sourceFile, "writeHandler");
-    if (parsed.kind === "error")
-        return parsed;
-    return ok({
-        kind: "writeHandler",
-        source: parsed.pattern.source,
-        handlerName: parsed.pattern.handlerName,
-        schemaSource: parsed.pattern.schemaSource,
-        handlerBody: parsed.pattern.handlerBody,
-        ...(parsed.pattern.access !== undefined && { access: parsed.pattern.access }),
-        ...(parsed.pattern.description !== undefined && { description: parsed.pattern.description }),
-        ...(parsed.pattern.agent !== undefined && { agent: parsed.pattern.agent }),
-        ...(parsed.pattern.rateLimit !== undefined && { rateLimit: parsed.pattern.rateLimit }),
-        ...(parsed.pattern.additionalRateLimits !== undefined && {
-            additionalRateLimits: parsed.pattern.additionalRateLimits,
-        }),
-        ...(parsed.pattern.unsafeSkipTransitionGuard === true && { unsafeSkipTransitionGuard: true }),
-        ...(parsed.pattern.escapeHatch !== undefined && { escapeHatch: parsed.pattern.escapeHatch }),
-    });
-}
-function readHandlerFields(parsed) {
-    return {
-        source: parsed.pattern.source,
-        handlerName: parsed.pattern.handlerName,
-        schemaSource: parsed.pattern.schemaSource,
-        handlerBody: parsed.pattern.handlerBody,
-        ...(parsed.pattern.access !== undefined && { access: parsed.pattern.access }),
-        ...(parsed.pattern.rateLimit !== undefined && { rateLimit: parsed.pattern.rateLimit }),
-        ...(parsed.pattern.escapeHatch !== undefined && { escapeHatch: parsed.pattern.escapeHatch }),
-    };
-}
-export function extractQueryHandler(call, sourceFile) {
-    const parsed = parseHandlerCall(call, sourceFile, "queryHandler");
-    if (parsed.kind === "error")
-        return parsed;
-    return ok({
-        kind: "queryHandler",
-        ...readHandlerFields(parsed),
-        ...(parsed.pattern.description !== undefined && { description: parsed.pattern.description }),
-        ...(parsed.pattern.agent !== undefined && { agent: parsed.pattern.agent }),
-    });
-}
-// StreamHandlerDef has no description/agent at runtime, unlike escapeHatch,
-// so readHandlerFields forwards only access/rateLimit/escapeHatch.
-export function extractStreamHandler(call, sourceFile) {
-    const parsed = parseHandlerCall(call, sourceFile, "streamHandler");
-    if (parsed.kind === "error")
-        return parsed;
-    return ok({ kind: "streamHandler", ...readHandlerFields(parsed) });
-}

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

@@ -1,24 +0,0 @@
-import type { CallExpression, Node, SourceFile } from "ts-morph";
-import type { LifecycleHookType } from "../../constants.ts";
-import type { AccessRule, EscapeHatchDeclaration, PayloadRateLimitOption, RateLimitDeclaration } from "../../types/handlers.ts";
-import type { HookPhase } from "../../types/hooks.ts";
-import type { AuthClaimsPattern, HookPattern } from "../patterns.ts";
-import { type ExtractOutput, type RawRefSentinel } from "./shared.ts";
-export type HeaderReadResult<T> = {
-    readonly kind: "value";
-    readonly value: T;
-} | {
-    readonly kind: "raw";
-    readonly sentinel: RawRefSentinel;
-} | {
-    readonly kind: "unrecognized";
-};
-export declare function readHeaderValueOrRaw<T>(init: Node, recognize: (value: unknown) => T | undefined): HeaderReadResult<T>;
-export declare function isHookType(value: string): value is LifecycleHookType | "validation";
-export declare function readOptionalPhase(node: Node | undefined): HookPhase | undefined;
-export declare function readOptionalAccessRule(value: unknown): AccessRule | undefined;
-export declare function readOptionalRateLimit(value: unknown): RateLimitDeclaration | undefined;
-export declare function readOptionalAdditionalRateLimits(value: unknown): readonly PayloadRateLimitOption[] | undefined;
-export declare function readOptionalEscapeHatch(value: unknown): EscapeHatchDeclaration | undefined;
-export declare function extractHook(call: CallExpression, sourceFile: SourceFile): ExtractOutput<HookPattern>;
-export declare function extractAuthClaims(call: CallExpression, sourceFile: SourceFile): ExtractOutput<AuthClaimsPattern>;

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

@@ -1,248 +0,0 @@
-import { isEscapeHatchGrant, isRateLimitOption } from "@cosmicdrift/kumiko-types/handlers";
-import { SyntaxKind } from "ts-morph";
-import { sourceLocationFromNode } from "../source-location.js";
-import { containsRawRefSentinel, fail, findFunctionLiteral, isPlainObject, ok, readDataLiteralNode, readNameLiteral, readNameOrRef, readNameOrRefOrList, readObjectPropertyInitializer, } from "./shared.js";
-// Raw-sentinel check runs before recognize: recognize narrows literals and
-// would silently drop a nested reference (e.g. roles array plus a
-// non-literal personalData) that the whole-object narrowing can't see.
-export function readHeaderValueOrRaw(init, recognize) {
-    const value = readDataLiteralNode(init);
-    if (value === undefined || containsRawRefSentinel(value)) {
-        return { kind: "raw", sentinel: { __raw: init.getText() } };
-    }
-    const recognized = recognize(value);
-    if (recognized === undefined)
-        return { kind: "unrecognized" };
-    return { kind: "value", value: recognized };
-}
-export function isHookType(value) {
-    return (value === "preSave" ||
-        value === "postSave" ||
-        value === "preDelete" ||
-        value === "postDelete" ||
-        value === "preQuery" ||
-        value === "validation");
-}
-export function readOptionalPhase(node) {
-    if (!node)
-        return undefined;
-    const obj = readDataLiteralNode(node);
-    if (!isPlainObject(obj))
-        return undefined;
-    const phase = obj["phase"];
-    if (phase === "inTransaction" || phase === "afterCommit")
-        return phase;
-    return undefined;
-}
-// `openToAll: true` (deprecated) is not recognised here — isOpenToAllGranted never grants it, so extracting it would round-trip a rule that looks configured but denies everyone.
-export function readOptionalAccessRule(value) {
-    if (!isPlainObject(value))
-        return undefined;
-    if (Array.isArray(value["roles"]) && value["roles"].every((r) => typeof r === "string")) {
-        const personalData = value["personalData"] === "public-intake" ? { personalData: "public-intake" } : {};
-        return { roles: value["roles"], ...personalData };
-    }
-    const openToAll = value["openToAll"];
-    if (isPlainObject(openToAll) && typeof openToAll["reason"] === "string") {
-        const personalData = openToAll["personalData"] === "tenant-members"
-            ? { personalData: "tenant-members" }
-            : {};
-        return { openToAll: { reason: openToAll["reason"], ...personalData } };
-    }
-    return undefined;
-}
-export function readOptionalRateLimit(value) {
-    if (Array.isArray(value)) {
-        if (!value.every(isRateLimitOption))
-            return undefined;
-        const [first, ...rest] = value;
-        return first === undefined ? undefined : [first, ...rest];
-    }
-    if (!isPlainObject(value))
-        return undefined;
-    if (value["disabled"] === true) {
-        // Strict shape: exactly { disabled: true, reason } — anything extra
-        // isn't RateLimitDisabled and falls through to "unrecognized".
-        if (typeof value["reason"] !== "string")
-            return undefined;
-        if (Object.keys(value).length !== 2)
-            return undefined;
-        return { disabled: true, reason: value["reason"] };
-    }
-    return isRateLimitOption(value) ? value : undefined;
-}
-function isPayloadRateLimitOption(value) {
-    if (!isPlainObject(value))
-        return false;
-    const per = value["per"];
-    return (isPlainObject(per) &&
-        typeof per["payloadField"] === "string" &&
-        typeof value["limit"] === "number" &&
-        typeof value["windowSeconds"] === "number");
-}
-export function readOptionalAdditionalRateLimits(value) {
-    if (!Array.isArray(value) || !value.every(isPayloadRateLimitOption))
-        return undefined;
-    return value;
-}
-export function readOptionalEscapeHatch(value) {
-    if (!isPlainObject(value))
-        return undefined;
-    if (typeof value["reason"] !== "string")
-        return undefined;
-    const grants = value["grants"];
-    if (grants === undefined)
-        return { reason: value["reason"] };
-    if (!Array.isArray(grants) || !grants.every(isEscapeHatchGrant))
-        return undefined;
-    return { reason: value["reason"], grants };
-}
-// Reads the `escapeHatch` sub-property node first, not via readDataLiteralNode
-// on the whole object: a sibling property like `handler` (a closure) isn't
-// representable as plain data, which would make the whole-object read
-// return undefined. undefined means the property is absent, not an error.
-function readOptionalHookEscapeHatch(node) {
-    const obj = node?.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (!obj)
-        return undefined;
-    const init = readObjectPropertyInitializer(obj, "escapeHatch");
-    if (!init)
-        return undefined;
-    return readHeaderValueOrRaw(init, readOptionalEscapeHatch);
-}
-// Resolves the hook's escapeHatch into either a field to spread into the
-// pattern, or a ParseError for a fully literal but unrecognized shape.
-function readHookEscapeHatch(node, call, sourceFile) {
-    const result = readOptionalHookEscapeHatch(node);
-    if (!result)
-        return {};
-    if (result.kind === "unrecognized") {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "escapeHatch must be { reason: string }, or a reference to one");
-    }
-    return { escapeHatch: result.kind === "value" ? result.value : result.sentinel };
-}
-// r.hook's target: a NameOrRef, a list of them, or an entity-wide
-// `{ allOf: entityRef }` (replaces the old r.entityHook(type, entity, fn)).
-// Checked first so a malformed `{ allOf }` doesn't silently fall through
-// to being read as some other object shape.
-function readHookTarget(node) {
-    const obj = node.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj) {
-        const allOfProp = obj.getProperty("allOf")?.asKind(SyntaxKind.PropertyAssignment);
-        if (allOfProp) {
-            const initializer = allOfProp.getInitializer();
-            const entityName = initializer && readNameOrRef(initializer);
-            return entityName ? { allOf: entityName } : undefined;
-        }
-    }
-    return readNameOrRefOrList(node);
-}
-export function extractHook(call, sourceFile) {
-    const args = call.getArguments();
-    const first = args[0];
-    if (!first) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
-    }
-    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (obj && args.length === 1) {
-        const typeInit = obj
-            .getProperty("type")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer()
-            ?.asKind(SyntaxKind.StringLiteral);
-        if (!typeInit) {
-            return fail("hook", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `type` property");
-        }
-        const hookType = typeInit.getLiteralValue();
-        if (!isHookType(hookType)) {
-            return fail("hook", sourceLocationFromNode(call, sourceFile), `hook type "${hookType}" is not one of the lifecycle types or "validation"`);
-        }
-        const targetInit = obj
-            .getProperty("target")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!targetInit) {
-            return fail("hook", sourceLocationFromNode(call, sourceFile), "object form requires a `target` property");
-        }
-        const target = readHookTarget(targetInit);
-        if (!target) {
-            return fail("hook", sourceLocationFromNode(call, sourceFile), "target must be a string literal, an inline { name } object, or an array");
-        }
-        const handlerInit = obj
-            .getProperty("handler")
-            ?.asKind(SyntaxKind.PropertyAssignment)
-            ?.getInitializer();
-        if (!handlerInit) {
-            return fail("hook", sourceLocationFromNode(call, sourceFile), "object form requires a `handler` property");
-        }
-        const fn = findFunctionLiteral(handlerInit);
-        if (!fn) {
-            return fail("hook", sourceLocationFromNode(call, sourceFile), "handler must be an inline arrow function or function expression");
-        }
-        const phase = readOptionalPhase(obj);
-        const escapeHatchOutcome = readHookEscapeHatch(obj, call, sourceFile);
-        if ("kind" in escapeHatchOutcome)
-            return escapeHatchOutcome;
-        return ok({
-            kind: "hook",
-            source: sourceLocationFromNode(call, sourceFile),
-            hookType,
-            target,
-            fnBody: sourceLocationFromNode(fn, sourceFile),
-            ...(phase !== undefined && { phase }),
-            ...escapeHatchOutcome,
-        });
-    }
-    const hookType = readNameLiteral(first);
-    if (hookType === undefined) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal hook type, or an identifier resolving to one (or use the object form)");
-    }
-    if (!isHookType(hookType)) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), `hook type "${hookType}" is not one of the lifecycle types or "validation"`);
-    }
-    const targetArg = args[1];
-    if (!targetArg) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "expected a target (NameOrRef or array) as second argument");
-    }
-    const target = readHookTarget(targetArg);
-    if (!target) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "target must be a string literal, an inline { name } object, or an array");
-    }
-    const fnArg = args[2];
-    if (!fnArg) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "expected a hook function as third argument");
-    }
-    const fn = findFunctionLiteral(fnArg);
-    if (!fn) {
-        return fail("hook", sourceLocationFromNode(call, sourceFile), "third argument must be an inline arrow function or function expression");
-    }
-    const phase = readOptionalPhase(args[3]);
-    const escapeHatchOutcome = readHookEscapeHatch(args[3], call, sourceFile);
-    if ("kind" in escapeHatchOutcome)
-        return escapeHatchOutcome;
-    return ok({
-        kind: "hook",
-        source: sourceLocationFromNode(call, sourceFile),
-        hookType,
-        target,
-        fnBody: sourceLocationFromNode(fn, sourceFile),
-        ...(phase !== undefined && { phase }),
-        ...escapeHatchOutcome,
-    });
-}
-// guard:dup-ok — intentional parallel to extractTree; different Feature-AST extractors by design
-export function extractAuthClaims(call, sourceFile) {
-    const arg = call.getArguments()[0];
-    if (!arg) {
-        return fail("authClaims", sourceLocationFromNode(call, sourceFile), "expected a function as first argument");
-    }
-    const fn = findFunctionLiteral(arg);
-    if (!fn) {
-        return fail("authClaims", sourceLocationFromNode(call, sourceFile), "first argument must be an inline arrow function or function expression");
-    }
-    return ok({
-        kind: "authClaims",
-        source: sourceLocationFromNode(call, sourceFile),
-        fnBody: sourceLocationFromNode(fn, sourceFile),
-    });
-}

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

@@ -1,14 +0,0 @@
-export { extractAiClassify, extractAiExtract, extractAiGenerate, } from "./ai-steps.ts";
-export { extractDefineEvent, extractNotification, } from "./events.ts";
-export { extractQueryHandler, extractStreamHandler, extractWriteHandler, type ParsedHandlerCall, parseHandlerCall, } from "./handlers.ts";
-export { extractAuthClaims, extractHook, isHookType, readOptionalAccessRule, readOptionalAdditionalRateLimits, readOptionalPhase, readOptionalRateLimit, } from "./hooks.ts";
-export { extractHttpRoute, extractJob, isHttpRouteMethod, } from "./jobs-routes.ts";
-export { collectScreenOpaqueProps, extractMultiStreamProjection, extractProjection, extractScreen, readApplyBodies, readScreenStatic, } from "./projections-screens.ts";
-export { findImportBindingForLocalName, resolveModuleFile, } from "./resolve-import.ts";
-export { extractAdoptsBundledLists, extractDescribe, extractOptionalRequires, extractReadsConfig, extractRequires, extractSystemScope, extractToggleable, extractUiHints, } from "./round1.ts";
-export { extractEntity, extractNav, extractRelation, extractWorkspace, } from "./round2.ts";
-export { extractClaimKey, extractConfig, extractMetric, extractReferenceData, extractSecret, extractSecretNamespace, extractTranslations, extractUseExtension, isClaimKeyType, type NamedOptionsResult, readNamedOptions, } from "./round3.ts";
-export { extractBootCheck, extractEnvSchema, extractExposesApi, extractExtendsRegistrar, extractStoreTable, extractUsesApi, } from "./round5.ts";
-export { extractTreeActions } from "./round6.ts";
-export type { ExtractOutput } from "./shared.ts";
-export { fail, findFunctionLiteral, isPlainObject, ok, readBooleanProperty, readDataLiteralNode, readNameOrRef, readNameOrRefOrList, readObjectPropertyInitializer, readPropertyKey, readStringLiteralArgs, readVarargsOrArrayProp, resolveSameFileObjectLiteral, } from "./shared.ts";

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

@@ -1,13 +0,0 @@
-export { extractAiClassify, extractAiExtract, extractAiGenerate, } from "./ai-steps.js";
-export { extractDefineEvent, extractNotification, } from "./events.js";
-export { extractQueryHandler, extractStreamHandler, extractWriteHandler, parseHandlerCall, } from "./handlers.js";
-export { extractAuthClaims, extractHook, isHookType, readOptionalAccessRule, readOptionalAdditionalRateLimits, readOptionalPhase, readOptionalRateLimit, } from "./hooks.js";
-export { extractHttpRoute, extractJob, isHttpRouteMethod, } from "./jobs-routes.js";
-export { collectScreenOpaqueProps, extractMultiStreamProjection, extractProjection, extractScreen, readApplyBodies, readScreenStatic, } from "./projections-screens.js";
-export { findImportBindingForLocalName, resolveModuleFile, } from "./resolve-import.js";
-export { extractAdoptsBundledLists, extractDescribe, extractOptionalRequires, extractReadsConfig, extractRequires, extractSystemScope, extractToggleable, extractUiHints, } from "./round1.js";
-export { extractEntity, extractNav, extractRelation, extractWorkspace, } from "./round2.js";
-export { extractClaimKey, extractConfig, extractMetric, extractReferenceData, extractSecret, extractSecretNamespace, extractTranslations, extractUseExtension, isClaimKeyType, readNamedOptions, } from "./round3.js";
-export { extractBootCheck, extractEnvSchema, extractExposesApi, extractExtendsRegistrar, extractStoreTable, extractUsesApi, } from "./round5.js";
-export { extractTreeActions } from "./round6.js";
-export { fail, findFunctionLiteral, isPlainObject, ok, readBooleanProperty, readDataLiteralNode, readNameOrRef, readNameOrRefOrList, readObjectPropertyInitializer, readPropertyKey, readStringLiteralArgs, readVarargsOrArrayProp, resolveSameFileObjectLiteral, } from "./shared.js";

package/dist/engine/feature-ast/extractors/jobs-routes.d.ts

@@ -1,7 +0,0 @@
-import type { CallExpression, SourceFile } from "ts-morph";
-import type { HttpRouteMethod } from "../../types/http-route.ts";
-import type { HttpRoutePattern, JobPattern } from "../patterns.ts";
-import { type ExtractOutput } from "./shared.ts";
-export declare function isHttpRouteMethod(value: string): value is HttpRouteMethod;
-export declare function extractJob(call: CallExpression, sourceFile: SourceFile): ExtractOutput<JobPattern>;
-export declare function extractHttpRoute(call: CallExpression, sourceFile: SourceFile): ExtractOutput<HttpRoutePattern>;