@cosmicdrift/kumiko-framework 0.387.0 → 0.389.0

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

@@ -33,7 +33,8 @@
 // roadmap C-Notes for the canonical-comment-attach Pattern that would
 // preserve prefixed `// kumiko-comment:` markers across roundtrips.
 import { SyntaxKind, } from "ts-morph";
-import { readNameLiteral, readNameOrRef, readPropertyKey, resolveSameFileObjectLiteral, } from "./extractors/shared.js";
+import { readPropertyKey } from "./extractors/shared.js";
+import { callMatchesId } from "./pattern-id-matchers.js";
 import { indent, PATTERN_INDENT, renderPattern, renderValue } from "./render.js";
 /**
  * Apply a sequence of changes to the source file in-place. The list is
@@ -481,6 +482,7 @@ export const SINGLETON_KINDS = new Set([
     "toggleable",
     "describe",
     "uiHints",
+    "adoptsBundledLists",
     "config",
     "translations",
     "authClaims",
@@ -523,7 +525,7 @@ function findCallForId(sourceFile, id) {
             continue;
         if (propAccess.getName() !== id.kind)
             continue;
-        if (callMatchesId(call, id))
+        if (callMatchesId(call, id.kind, id))
             matches.push(call);
     }
     if (SINGLETON_KINDS.has(id.kind) && matches.length > 1) {
@@ -536,28 +538,6 @@ const AI_STEP_FACTORY = {
     "ai.extract": "aiExtractStep",
     "ai.classify": "aiClassifyStep",
 };
-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;
-}
 function findAiStepCall(sourceFile, id) {
     if (!isAiStepId(id))
         return undefined;
@@ -566,7 +546,7 @@ function findAiStepCall(sourceFile, id) {
     for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
         if (call.getExpression().getText() !== factory)
             continue;
-        if (callMatchesId(call, id))
+        if (callMatchesId(call, id.kind, id))
             matches.push(call);
     }
     if (matches.length > 1) {
@@ -574,163 +554,6 @@ function findAiStepCall(sourceFile, id) {
     }
     return matches[0];
 }
-function callMatchesId(call, id) {
-    switch (id.kind) {
-        // Singletons: kind alone identifies the call.
-        case "requires":
-        case "optionalRequires":
-        case "readsConfig":
-        case "systemScope":
-        case "toggleable":
-        case "describe":
-        case "uiHints":
-        case "config":
-        case "translations":
-        case "authClaims":
-        case "treeActions":
-            return true;
-        case "entity":
-            return (matchFirstArgString(call, id.entityName) || matchObjectProperty(call, "name", id.entityName));
-        case "relation":
-            // Positional: r.relation(entity, name, def) | Object: { entity, name, ... }
-            if (matchFirstArgString(call, id.entityName)) {
-                return matchArgString(call, 1, id.relationName);
-            }
-            return (matchObjectProperty(call, "entity", id.entityName) &&
-                matchObjectProperty(call, "name", id.relationName));
-        case "nav":
-        case "workspace":
-        case "screen":
-            return matchObjectProperty(call, "id", id.id);
-        case "writeHandler":
-        case "queryHandler":
-        case "streamHandler":
-            return (matchFirstArgString(call, id.handlerName) ||
-                matchObjectProperty(call, "name", id.handlerName));
-        case "hook":
-            // Positional: r.hook(type, target, fn) | Object: { type, target }
-            if (typeof id.target === "object") {
-                // 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.
-                if (matchFirstArgString(call, id.hookType)) {
-                    return matchAllOfArg(call.getArguments()[1], id.target.allOf);
-                }
-                return (matchObjectProperty(call, "type", id.hookType) &&
-                    matchObjectAllOfProperty(call, "target", 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));
-        case "metric":
-        case "secret":
-        case "secretNamespace":
-        case "claimKey":
-            return (matchFirstArgString(call, id.shortName) || matchObjectProperty(call, "name", id.shortName));
-        case "referenceData":
-            return (matchFirstArgString(call, id.entityName) ||
-                matchObjectProperty(call, "entity", id.entityName));
-        case "useExtension":
-            // Positional: r.useExtension(name, entity) | Object: { name, entity }
-            if (matchFirstArgString(call, id.extensionName)) {
-                return matchArgNameOrRef(call, 1, id.entityName);
-            }
-            return (matchObjectProperty(call, "name", id.extensionName) &&
-                matchObjectProperty(call, "entity", id.entityName));
-        case "job":
-            return matchFirstArgString(call, id.jobName) || matchObjectProperty(call, "name", id.jobName);
-        case "notification":
-            return (matchFirstArgString(call, id.notificationName) ||
-                matchObjectProperty(call, "name", id.notificationName));
-        case "httpRoute":
-            // Object form only; positional doesn't apply.
-            return (matchObjectProperty(call, "method", id.method) && matchObjectProperty(call, "path", id.path));
-        case "projection":
-        case "multiStreamProjection":
-            return matchObjectProperty(call, "name", id.name);
-        case "defineEvent":
-            return (matchFirstArgString(call, id.eventName) || matchObjectProperty(call, "name", id.eventName));
-        case "extendsRegistrar":
-            return matchFirstArgString(call, id.extensionName);
-        case "ai.generate":
-        case "ai.extract":
-        case "ai.classify":
-            return readAiStepKey(call) === id.stepKey;
-        default: {
-            const _exhaustive = id;
-            return _exhaustive;
-        }
-    }
-}
-// 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);
-}
 // =============================================================================
 // Format helpers — line boundaries / blank-line collapse
 // (indent / PATTERN_INDENT live in render.ts and are imported above.)

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

@@ -7,6 +7,7 @@ import type { RelationDefinition } from "../types/relations.ts";
 import type { ScreenDefinition } from "../types/screen.ts";
 import type { TreeActionDef } from "../types/tree-node.ts";
 import type { WorkspaceDefinition } from "../types/workspace.ts";
+import type { RawRefSentinel } from "./extractors/shared.ts";
 import type { PatternChange } from "./patch.ts";
 import type { SourceLocation } from "./source-location.ts";
 export type PatternChangeIssue = {
@@ -26,6 +27,7 @@ export declare const PATTERN_SCHEMAS_BY_KIND: {
         source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
         entityName: z.ZodString;
         definition: z.ZodType<EntityDefinition, unknown, z.core.$ZodTypeInternals<EntityDefinition, unknown>>;
+        backingTable: z.ZodOptional<z.ZodType<RawRefSentinel, unknown, z.core.$ZodTypeInternals<RawRefSentinel, unknown>>>;
     }, z.core.$strict>;
     relation: z.ZodObject<{
         kind: z.ZodLiteral<"relation">;
@@ -82,6 +84,10 @@ export declare const PATTERN_SCHEMAS_BY_KIND: {
         kind: z.ZodLiteral<"uiHints">;
         source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
     }, z.core.$strict>;
+    adoptsBundledLists: z.ZodObject<{
+        kind: z.ZodLiteral<"adoptsBundledLists">;
+        source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
+    }, z.core.$strict>;
     metric: z.ZodObject<{
         kind: z.ZodLiteral<"metric">;
         source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
@@ -648,6 +654,7 @@ export declare const patternSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
     entityName: z.ZodString;
     definition: z.ZodType<EntityDefinition, unknown, z.core.$ZodTypeInternals<EntityDefinition, unknown>>;
+    backingTable: z.ZodOptional<z.ZodType<RawRefSentinel, unknown, z.core.$ZodTypeInternals<RawRefSentinel, unknown>>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"relation">;
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
@@ -692,6 +699,9 @@ export declare const patternSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"uiHints">;
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"adoptsBundledLists">;
+    source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"metric">;
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
@@ -1225,249 +1235,4 @@ export declare const patternSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
     methodName: z.ZodString;
 }, z.core.$strict>], "kind">;
-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>;
-    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<"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">;
 export declare function parsePatternChanges(input: unknown): PatternChangesParseResult;