@cosmicdrift/kumiko-framework 0.389.0 → 0.390.1

package/dist/engine/feature-ast/pattern-id-matchers.d.ts

@@ -1,7 +0,0 @@
-import { type CallExpression } from "ts-morph";
-import type { PatternId } from "./patch.ts";
-import type { MembersByKind } from "./patterns.ts";
-type PatternIdKind = PatternId["kind"];
-type PatternIdOfKind = MembersByKind<PatternId>;
-export declare function callMatchesId<K extends PatternIdKind>(call: CallExpression, kind: K, id: PatternIdOfKind[K]): boolean;
-export {};

package/dist/engine/feature-ast/pattern-id-matchers.js

@@ -1,211 +0,0 @@
-import { SyntaxKind } from "ts-morph";
-import { readNameLiteral, readNameOrRef, resolveSameFileObjectLiteral, } from "./extractors/shared.js";
-const PATTERN_ID_MATCHERS = {
-    requires: matchSingletonCall,
-    optionalRequires: matchSingletonCall,
-    readsConfig: matchSingletonCall,
-    systemScope: matchSingletonCall,
-    toggleable: matchSingletonCall,
-    describe: matchSingletonCall,
-    uiHints: matchSingletonCall,
-    adoptsBundledLists: matchSingletonCall,
-    config: matchSingletonCall,
-    translations: matchSingletonCall,
-    authClaims: matchSingletonCall,
-    treeActions: matchSingletonCall,
-    entity: matchEntityCall,
-    relation: matchRelationCall,
-    nav: matchIdPropertyCall,
-    workspace: matchIdPropertyCall,
-    screen: matchIdPropertyCall,
-    writeHandler: matchHandlerCall,
-    queryHandler: matchHandlerCall,
-    streamHandler: matchHandlerCall,
-    hook: matchHookCall,
-    metric: matchShortNameCall,
-    secret: matchShortNameCall,
-    secretNamespace: matchShortNameCall,
-    claimKey: matchShortNameCall,
-    referenceData: matchReferenceDataCall,
-    useExtension: matchUseExtensionCall,
-    job: matchJobCall,
-    notification: matchNotificationCall,
-    httpRoute: matchHttpRouteCall,
-    projection: matchProjectionCall,
-    multiStreamProjection: matchProjectionCall,
-    defineEvent: matchDefineEventCall,
-    extendsRegistrar: matchExtendsRegistrarCall,
-    "ai.generate": matchAiStepCall,
-    "ai.extract": matchAiStepCall,
-    "ai.classify": matchAiStepCall,
-};
-export function callMatchesId(call, kind, id) {
-    return PATTERN_ID_MATCHERS[kind](call, id);
-}
-// Singletons: kind alone identifies the call.
-function matchSingletonCall() {
-    return true;
-}
-function matchEntityCall(call, id) {
-    return (matchFirstArgString(call, id.entityName) || matchObjectProperty(call, "name", id.entityName));
-}
-// Positional: r.relation(entity, name, def) | Object: { entity, name, ... }
-function matchRelationCall(call, id) {
-    if (matchFirstArgString(call, id.entityName)) {
-        return matchArgString(call, 1, id.relationName);
-    }
-    return (matchObjectProperty(call, "entity", id.entityName) &&
-        matchObjectProperty(call, "name", id.relationName));
-}
-function matchIdPropertyCall(call, id) {
-    return matchObjectProperty(call, "id", id.id);
-}
-function matchHandlerCall(call, id) {
-    return (matchFirstArgString(call, id.handlerName) || matchObjectProperty(call, "name", id.handlerName));
-}
-// Positional: r.hook(type, target, fn) | Object: { type, target }
-function matchHookCall(call, id) {
-    if (typeof id.target === "object") {
-        return matchHookAllOfCall(call, id.hookType, id.target.allOf);
-    }
-    if (matchFirstArgString(call, id.hookType)) {
-        return matchArgNameOrRef(call, 1, id.target);
-    }
-    return (matchObjectProperty(call, "type", id.hookType) && matchObjectProperty(call, "target", id.target));
-}
-// Entity-wide { allOf } target — only ever appears as the object
-// literal { allOf: entity } (positional or nested in the object
-// form), never as a bare string, so check both call shapes.
-function matchHookAllOfCall(call, hookType, allOfEntity) {
-    if (matchFirstArgString(call, hookType)) {
-        return matchAllOfArg(call.getArguments()[1], allOfEntity);
-    }
-    return (matchObjectProperty(call, "type", hookType) &&
-        matchObjectAllOfProperty(call, "target", allOfEntity));
-}
-function matchShortNameCall(call, id) {
-    return matchFirstArgString(call, id.shortName) || matchObjectProperty(call, "name", id.shortName);
-}
-function matchReferenceDataCall(call, id) {
-    return (matchFirstArgString(call, id.entityName) || matchObjectProperty(call, "entity", id.entityName));
-}
-// Positional: r.useExtension(name, entity) | Object: { name, entity }
-function matchUseExtensionCall(call, id) {
-    if (matchFirstArgString(call, id.extensionName)) {
-        return matchArgNameOrRef(call, 1, id.entityName);
-    }
-    return (matchObjectProperty(call, "name", id.extensionName) &&
-        matchObjectProperty(call, "entity", id.entityName));
-}
-function matchJobCall(call, id) {
-    return matchFirstArgString(call, id.jobName) || matchObjectProperty(call, "name", id.jobName);
-}
-function matchNotificationCall(call, id) {
-    return (matchFirstArgString(call, id.notificationName) ||
-        matchObjectProperty(call, "name", id.notificationName));
-}
-// Object form only; positional doesn't apply.
-function matchHttpRouteCall(call, id) {
-    return (matchObjectProperty(call, "method", id.method) && matchObjectProperty(call, "path", id.path));
-}
-function matchProjectionCall(call, id) {
-    return matchObjectProperty(call, "name", id.name);
-}
-function matchDefineEventCall(call, id) {
-    return matchFirstArgString(call, id.eventName) || matchObjectProperty(call, "name", id.eventName);
-}
-function matchExtendsRegistrarCall(call, id) {
-    return matchFirstArgString(call, id.extensionName);
-}
-function matchAiStepCall(call, id) {
-    return readAiStepKey(call) === id.stepKey;
-}
-function readAiStepKey(call) {
-    const arg = call.getArguments()[0];
-    if (!arg)
-        return undefined;
-    const obj = resolveSameFileObjectLiteral(arg);
-    if (!obj)
-        return undefined;
-    const prop = obj.getProperty("stepKey");
-    if (!prop)
-        return undefined;
-    const assign = prop.asKind(SyntaxKind.PropertyAssignment);
-    if (assign) {
-        const init = assign.getInitializer();
-        if (!init)
-            return undefined;
-        return readNameLiteral(init);
-    }
-    const shorthand = prop.asKind(SyntaxKind.ShorthandPropertyAssignment);
-    if (shorthand)
-        return readNameLiteral(shorthand.getNameNode());
-    return undefined;
-}
-// Resolves an argument the same way the extractors do (readNameLiteral):
-// a string literal directly, or a bare identifier following its
-// declaration (same-file or imported) to a string-literal initializer —
-// the dominant naming style in the framework's own bundled-features
-// (`r.entity(ENTITY, ...)`, `r.useExtension(EXT_X, ...)`).
-//
-// Narrow on purpose: every kind's arg-0 (and relation's arg-1) is parsed
-// via readNameLiteral, never readNameOrRef (see round2.ts/round3.ts) —
-// widening this shared helper to readNameOrRef would let an object-form
-// call's first argument (an ObjectLiteralExpression) match here too,
-// short-circuiting the object-form branch in callMatchesId. Positions
-// where the parser itself accepts an inline `{ name: "..." }` ref use
-// `matchArgNameOrRef` below instead.
-function matchArgString(call, index, expected) {
-    const arg = call.getArguments()[index];
-    if (!arg)
-        return false;
-    return readNameLiteral(arg) === expected;
-}
-// @wrapper-known semantic-alias
-function matchFirstArgString(call, expected) {
-    return matchArgString(call, 0, expected);
-}
-// Like matchArgString, but via readNameOrRef — for the specific positional
-// slots where the parser accepts an inline `{ name: "..." }` object ref in
-// addition to a literal/identifier (useExtension's entity arg, hook's
-// target arg; see round3.ts:445 / hooks.ts:75). Not a drop-in replacement
-// for matchArgString: applying it to an arg-0 position would match an
-// object-form call's first (and only) argument, see the comment above.
-function matchArgNameOrRef(call, index, expected) {
-    const arg = call.getArguments()[index];
-    if (!arg)
-        return false;
-    return readNameOrRef(arg) === expected;
-}
-// Object-form property values are resolved via readNameOrRef, not the
-// narrower readNameLiteral — some properties (useExtension's `entity`,
-// hook's `target`/`allOf`) accept an inline `{ name: "..." }` ref in the
-// parser (see extractors/round3.ts, extractors/hooks.ts), not just a
-// literal or identifier. readNameOrRef is a superset of readNameLiteral,
-// so this is safe for every other property too.
-function matchObjectProperty(call, propName, expected) {
-    const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
-    if (!obj)
-        return false;
-    const init = obj.getProperty(propName)?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
-    if (!init)
-        return false;
-    return readNameOrRef(init) === expected;
-}
-// Matches an r.hook `{ allOf: entity }` target — as the arg node directly
-// (positional call form) or as a nested object property (object call form).
-function matchAllOfArg(node, expectedEntity) {
-    const obj = node?.asKind(SyntaxKind.ObjectLiteralExpression);
-    const init = obj?.getProperty("allOf")?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
-    if (!init)
-        return false;
-    return readNameOrRef(init) === expectedEntity;
-}
-function matchObjectAllOfProperty(call, propName, expectedEntity) {
-    const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
-    const propInit = obj
-        ?.getProperty(propName)
-        ?.asKind(SyntaxKind.PropertyAssignment)
-        ?.getInitializer();
-    return matchAllOfArg(propInit, expectedEntity);
-}

package/dist/engine/feature-ast/pattern-id-schema.d.ts

@@ -1,251 +0,0 @@
-import * as z from "zod";
-export declare const PATTERN_ID_SCHEMAS_BY_KIND: {
-    entity: z.ZodObject<{
-        kind: z.ZodLiteral<"entity">;
-        entityName: z.ZodString;
-    }, z.core.$strict>;
-    relation: z.ZodObject<{
-        kind: z.ZodLiteral<"relation">;
-        entityName: z.ZodString;
-        relationName: z.ZodString;
-    }, z.core.$strict>;
-    nav: z.ZodObject<{
-        kind: z.ZodLiteral<"nav">;
-        id: z.ZodString;
-    }, z.core.$strict>;
-    workspace: z.ZodObject<{
-        kind: z.ZodLiteral<"workspace">;
-        id: z.ZodString;
-    }, z.core.$strict>;
-    screen: z.ZodObject<{
-        kind: z.ZodLiteral<"screen">;
-        id: z.ZodString;
-    }, z.core.$strict>;
-    writeHandler: z.ZodObject<{
-        kind: z.ZodLiteral<"writeHandler">;
-        handlerName: z.ZodString;
-    }, z.core.$strict>;
-    queryHandler: z.ZodObject<{
-        kind: z.ZodLiteral<"queryHandler">;
-        handlerName: z.ZodString;
-    }, z.core.$strict>;
-    streamHandler: z.ZodObject<{
-        kind: z.ZodLiteral<"streamHandler">;
-        handlerName: z.ZodString;
-    }, z.core.$strict>;
-    hook: z.ZodObject<{
-        kind: z.ZodLiteral<"hook">;
-        hookType: z.ZodString;
-        target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-            allOf: z.ZodString;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>;
-    metric: z.ZodObject<{
-        kind: z.ZodLiteral<"metric">;
-        shortName: z.ZodString;
-    }, z.core.$strict>;
-    secret: z.ZodObject<{
-        kind: z.ZodLiteral<"secret">;
-        shortName: z.ZodString;
-    }, z.core.$strict>;
-    secretNamespace: z.ZodObject<{
-        kind: z.ZodLiteral<"secretNamespace">;
-        shortName: z.ZodString;
-    }, z.core.$strict>;
-    claimKey: z.ZodObject<{
-        kind: z.ZodLiteral<"claimKey">;
-        shortName: z.ZodString;
-    }, z.core.$strict>;
-    referenceData: z.ZodObject<{
-        kind: z.ZodLiteral<"referenceData">;
-        entityName: z.ZodString;
-    }, z.core.$strict>;
-    useExtension: z.ZodObject<{
-        kind: z.ZodLiteral<"useExtension">;
-        extensionName: z.ZodString;
-        entityName: z.ZodString;
-    }, z.core.$strict>;
-    job: z.ZodObject<{
-        kind: z.ZodLiteral<"job">;
-        jobName: z.ZodString;
-    }, z.core.$strict>;
-    notification: z.ZodObject<{
-        kind: z.ZodLiteral<"notification">;
-        notificationName: z.ZodString;
-    }, z.core.$strict>;
-    httpRoute: z.ZodObject<{
-        kind: z.ZodLiteral<"httpRoute">;
-        method: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strict>;
-    projection: z.ZodObject<{
-        kind: z.ZodLiteral<"projection">;
-        name: z.ZodString;
-    }, z.core.$strict>;
-    multiStreamProjection: z.ZodObject<{
-        kind: z.ZodLiteral<"multiStreamProjection">;
-        name: z.ZodString;
-    }, z.core.$strict>;
-    defineEvent: z.ZodObject<{
-        kind: z.ZodLiteral<"defineEvent">;
-        eventName: z.ZodString;
-    }, z.core.$strict>;
-    extendsRegistrar: z.ZodObject<{
-        kind: z.ZodLiteral<"extendsRegistrar">;
-        extensionName: z.ZodString;
-    }, z.core.$strict>;
-    "ai.generate": z.ZodObject<{
-        kind: z.ZodLiteral<"ai.generate">;
-        stepKey: z.ZodString;
-    }, z.core.$strict>;
-    "ai.extract": z.ZodObject<{
-        kind: z.ZodLiteral<"ai.extract">;
-        stepKey: z.ZodString;
-    }, z.core.$strict>;
-    "ai.classify": z.ZodObject<{
-        kind: z.ZodLiteral<"ai.classify">;
-        stepKey: z.ZodString;
-    }, z.core.$strict>;
-    requires: z.ZodObject<{
-        kind: z.ZodLiteral<"requires">;
-    }, z.core.$strict>;
-    optionalRequires: z.ZodObject<{
-        kind: z.ZodLiteral<"optionalRequires">;
-    }, z.core.$strict>;
-    readsConfig: z.ZodObject<{
-        kind: z.ZodLiteral<"readsConfig">;
-    }, z.core.$strict>;
-    systemScope: z.ZodObject<{
-        kind: z.ZodLiteral<"systemScope">;
-    }, z.core.$strict>;
-    toggleable: z.ZodObject<{
-        kind: z.ZodLiteral<"toggleable">;
-    }, z.core.$strict>;
-    describe: z.ZodObject<{
-        kind: z.ZodLiteral<"describe">;
-    }, z.core.$strict>;
-    uiHints: z.ZodObject<{
-        kind: z.ZodLiteral<"uiHints">;
-    }, z.core.$strict>;
-    adoptsBundledLists: z.ZodObject<{
-        kind: z.ZodLiteral<"adoptsBundledLists">;
-    }, z.core.$strict>;
-    config: z.ZodObject<{
-        kind: z.ZodLiteral<"config">;
-    }, z.core.$strict>;
-    translations: z.ZodObject<{
-        kind: z.ZodLiteral<"translations">;
-    }, z.core.$strict>;
-    authClaims: z.ZodObject<{
-        kind: z.ZodLiteral<"authClaims">;
-    }, z.core.$strict>;
-    treeActions: z.ZodObject<{
-        kind: z.ZodLiteral<"treeActions">;
-    }, z.core.$strict>;
-};
-export declare const patternIdSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"entity">;
-    entityName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"relation">;
-    entityName: z.ZodString;
-    relationName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"nav">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"workspace">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"screen">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"writeHandler">;
-    handlerName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"queryHandler">;
-    handlerName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"streamHandler">;
-    handlerName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"hook">;
-    hookType: z.ZodString;
-    target: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        allOf: z.ZodString;
-    }, z.core.$strict>]>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"metric">;
-    shortName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"secret">;
-    shortName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"secretNamespace">;
-    shortName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"claimKey">;
-    shortName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"referenceData">;
-    entityName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"useExtension">;
-    extensionName: z.ZodString;
-    entityName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"job">;
-    jobName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"notification">;
-    notificationName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"httpRoute">;
-    method: z.ZodString;
-    path: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"projection">;
-    name: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"multiStreamProjection">;
-    name: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"defineEvent">;
-    eventName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"extendsRegistrar">;
-    extensionName: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"ai.generate">;
-    stepKey: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"ai.extract">;
-    stepKey: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"ai.classify">;
-    stepKey: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"requires">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"optionalRequires">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"readsConfig">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"systemScope">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"adoptsBundledLists">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"toggleable">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"describe">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"uiHints">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"config">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"translations">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"authClaims">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"treeActions">;
-}, z.core.$strict>], "kind">;

package/dist/engine/feature-ast/pattern-id-schema.js

@@ -1,166 +0,0 @@
-import * as z from "zod";
-const patternIdEntitySchema = z
-    .object({ kind: z.literal("entity"), entityName: z.string() })
-    .strict();
-const patternIdRelationSchema = z
-    .object({ kind: z.literal("relation"), entityName: z.string(), relationName: z.string() })
-    .strict();
-const patternIdNavSchema = z.object({ kind: z.literal("nav"), id: z.string() }).strict();
-const patternIdWorkspaceSchema = z
-    .object({ kind: z.literal("workspace"), id: z.string() })
-    .strict();
-const patternIdScreenSchema = z.object({ kind: z.literal("screen"), id: z.string() }).strict();
-const patternIdWriteHandlerSchema = z
-    .object({ kind: z.literal("writeHandler"), handlerName: z.string() })
-    .strict();
-const patternIdQueryHandlerSchema = z
-    .object({ kind: z.literal("queryHandler"), handlerName: z.string() })
-    .strict();
-const patternIdStreamHandlerSchema = z
-    .object({ kind: z.literal("streamHandler"), handlerName: z.string() })
-    .strict();
-const patternIdHookSchema = z
-    .object({
-    kind: z.literal("hook"),
-    hookType: z.string(),
-    target: z.union([z.string(), z.object({ allOf: z.string() }).strict()]),
-})
-    .strict();
-const patternIdMetricSchema = z
-    .object({ kind: z.literal("metric"), shortName: z.string() })
-    .strict();
-const patternIdSecretSchema = z
-    .object({ kind: z.literal("secret"), shortName: z.string() })
-    .strict();
-const patternIdSecretNamespaceSchema = z
-    .object({ kind: z.literal("secretNamespace"), shortName: z.string() })
-    .strict();
-const patternIdClaimKeySchema = z
-    .object({ kind: z.literal("claimKey"), shortName: z.string() })
-    .strict();
-const patternIdReferenceDataSchema = z
-    .object({ kind: z.literal("referenceData"), entityName: z.string() })
-    .strict();
-const patternIdUseExtensionSchema = z
-    .object({ kind: z.literal("useExtension"), extensionName: z.string(), entityName: z.string() })
-    .strict();
-const patternIdJobSchema = z.object({ kind: z.literal("job"), jobName: z.string() }).strict();
-const patternIdNotificationSchema = z
-    .object({ kind: z.literal("notification"), notificationName: z.string() })
-    .strict();
-const patternIdHttpRouteSchema = z
-    .object({ kind: z.literal("httpRoute"), method: z.string(), path: z.string() })
-    .strict();
-const patternIdProjectionSchema = z
-    .object({ kind: z.literal("projection"), name: z.string() })
-    .strict();
-const patternIdMultiStreamProjectionSchema = z
-    .object({ kind: z.literal("multiStreamProjection"), name: z.string() })
-    .strict();
-const patternIdDefineEventSchema = z
-    .object({ kind: z.literal("defineEvent"), eventName: z.string() })
-    .strict();
-const patternIdExtendsRegistrarSchema = z
-    .object({ kind: z.literal("extendsRegistrar"), extensionName: z.string() })
-    .strict();
-const patternIdAiGenerateSchema = z
-    .object({ kind: z.literal("ai.generate"), stepKey: z.string() })
-    .strict();
-const patternIdAiExtractSchema = z
-    .object({ kind: z.literal("ai.extract"), stepKey: z.string() })
-    .strict();
-const patternIdAiClassifySchema = z
-    .object({ kind: z.literal("ai.classify"), stepKey: z.string() })
-    .strict();
-const patternIdRequiresSchema = z.object({ kind: z.literal("requires") }).strict();
-const patternIdOptionalRequiresSchema = z.object({ kind: z.literal("optionalRequires") }).strict();
-const patternIdReadsConfigSchema = z.object({ kind: z.literal("readsConfig") }).strict();
-const patternIdSystemScopeSchema = z.object({ kind: z.literal("systemScope") }).strict();
-const patternIdToggleableSchema = z.object({ kind: z.literal("toggleable") }).strict();
-const patternIdDescribeSchema = z.object({ kind: z.literal("describe") }).strict();
-const patternIdUiHintsSchema = z.object({ kind: z.literal("uiHints") }).strict();
-const patternIdAdoptsBundledListsSchema = z
-    .object({ kind: z.literal("adoptsBundledLists") })
-    .strict();
-const patternIdConfigSchema = z.object({ kind: z.literal("config") }).strict();
-const patternIdTranslationsSchema = z.object({ kind: z.literal("translations") }).strict();
-const patternIdAuthClaimsSchema = z.object({ kind: z.literal("authClaims") }).strict();
-const patternIdTreeActionsSchema = z.object({ kind: z.literal("treeActions") }).strict();
-export const PATTERN_ID_SCHEMAS_BY_KIND = {
-    entity: patternIdEntitySchema,
-    relation: patternIdRelationSchema,
-    nav: patternIdNavSchema,
-    workspace: patternIdWorkspaceSchema,
-    screen: patternIdScreenSchema,
-    writeHandler: patternIdWriteHandlerSchema,
-    queryHandler: patternIdQueryHandlerSchema,
-    streamHandler: patternIdStreamHandlerSchema,
-    hook: patternIdHookSchema,
-    metric: patternIdMetricSchema,
-    secret: patternIdSecretSchema,
-    secretNamespace: patternIdSecretNamespaceSchema,
-    claimKey: patternIdClaimKeySchema,
-    referenceData: patternIdReferenceDataSchema,
-    useExtension: patternIdUseExtensionSchema,
-    job: patternIdJobSchema,
-    notification: patternIdNotificationSchema,
-    httpRoute: patternIdHttpRouteSchema,
-    projection: patternIdProjectionSchema,
-    multiStreamProjection: patternIdMultiStreamProjectionSchema,
-    defineEvent: patternIdDefineEventSchema,
-    extendsRegistrar: patternIdExtendsRegistrarSchema,
-    "ai.generate": patternIdAiGenerateSchema,
-    "ai.extract": patternIdAiExtractSchema,
-    "ai.classify": patternIdAiClassifySchema,
-    requires: patternIdRequiresSchema,
-    optionalRequires: patternIdOptionalRequiresSchema,
-    readsConfig: patternIdReadsConfigSchema,
-    systemScope: patternIdSystemScopeSchema,
-    toggleable: patternIdToggleableSchema,
-    describe: patternIdDescribeSchema,
-    uiHints: patternIdUiHintsSchema,
-    adoptsBundledLists: patternIdAdoptsBundledListsSchema,
-    config: patternIdConfigSchema,
-    translations: patternIdTranslationsSchema,
-    authClaims: patternIdAuthClaimsSchema,
-    treeActions: patternIdTreeActionsSchema,
-};
-export const patternIdSchema = z.discriminatedUnion("kind", [
-    patternIdEntitySchema,
-    patternIdRelationSchema,
-    patternIdNavSchema,
-    patternIdWorkspaceSchema,
-    patternIdScreenSchema,
-    patternIdWriteHandlerSchema,
-    patternIdQueryHandlerSchema,
-    patternIdStreamHandlerSchema,
-    patternIdHookSchema,
-    patternIdMetricSchema,
-    patternIdSecretSchema,
-    patternIdSecretNamespaceSchema,
-    patternIdClaimKeySchema,
-    patternIdReferenceDataSchema,
-    patternIdUseExtensionSchema,
-    patternIdJobSchema,
-    patternIdNotificationSchema,
-    patternIdHttpRouteSchema,
-    patternIdProjectionSchema,
-    patternIdMultiStreamProjectionSchema,
-    patternIdDefineEventSchema,
-    patternIdExtendsRegistrarSchema,
-    patternIdAiGenerateSchema,
-    patternIdAiExtractSchema,
-    patternIdAiClassifySchema,
-    patternIdRequiresSchema,
-    patternIdOptionalRequiresSchema,
-    patternIdReadsConfigSchema,
-    patternIdSystemScopeSchema,
-    patternIdAdoptsBundledListsSchema,
-    patternIdToggleableSchema,
-    patternIdDescribeSchema,
-    patternIdUiHintsSchema,
-    patternIdConfigSchema,
-    patternIdTranslationsSchema,
-    patternIdAuthClaimsSchema,
-    patternIdTreeActionsSchema,
-]);