@cosmicdrift/kumiko-framework 0.387.0 → 0.389.0

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

@@ -28,6 +28,7 @@ import { describeUnknownFieldType, findUnknownEntityFieldTypes } from "./entity-
 import { AGENT_RISK_VALUES } from "./extractors/handlers.js";
 import { isPlainObject, isRawRefSentinel } from "./extractors/shared.js";
 import { SYNTHETIC_LOC } from "./patcher.js";
+import { patternIdSchema } from "./pattern-id-schema.js";
 // Derives an exhaustive literal-value array from a `Record<T, true>` flag
 // map: an added/removed union member fails to compile here instead of
 // silently producing a schema narrower than the runtime type — same
@@ -332,6 +333,7 @@ const entitySchema = z
     source: sourceFieldSchema,
     entityName: z.string(),
     definition: entityDefinitionSchema,
+    backingTable: passthroughSchema().optional(),
 })
     .strict();
 const relationSchema = z
@@ -405,6 +407,12 @@ const describeSchema = z
     text: z.string().refine((s) => s.trim().length > 0, { message: "text must be non-empty" }),
 })
     .strict();
+const adoptsBundledListsSchema = z
+    .object({
+    kind: z.literal("adoptsBundledLists"),
+    source: sourceFieldSchema,
+})
+    .strict();
 const uiHintsSchema = z
     .object({
     kind: z.literal("uiHints"),
@@ -727,6 +735,7 @@ export const PATTERN_SCHEMAS_BY_KIND = {
     toggleable: toggleableSchema,
     describe: describeSchema,
     uiHints: uiHintsSchema,
+    adoptsBundledLists: adoptsBundledListsSchema,
     metric: metricSchema,
     secret: secretSchema,
     secretNamespace: secretNamespaceSchema,
@@ -769,6 +778,7 @@ export const patternSchema = z.discriminatedUnion("kind", [
     toggleableSchema,
     describeSchema,
     uiHintsSchema,
+    adoptsBundledListsSchema,
     metricSchema,
     secretSchema,
     secretNamespaceSchema,
@@ -799,169 +809,6 @@ export const patternSchema = z.discriminatedUnion("kind", [
     unknownPatternSchema,
 ]);
 // =============================================================================
-// PatternId union
-// =============================================================================
-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 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,
-    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,
-    patternIdToggleableSchema,
-    patternIdDescribeSchema,
-    patternIdUiHintsSchema,
-    patternIdConfigSchema,
-    patternIdTranslationsSchema,
-    patternIdAuthClaimsSchema,
-    patternIdTreeActionsSchema,
-]);
-// =============================================================================
 // Change union — `rationale` is accepted (optional, on every member) and
 // dropped when the final PatternChange is assembled below (plain field
 // selection, not a schema-level transform — see file-header rationale).

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,211 @@
+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

@@ -0,0 +1,251 @@
+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">;