@specverse/engines 6.42.3 → 6.60.1

package/dist/normalise/normalise-rules.js

@@ -0,0 +1,79 @@
+/**
+ * Normalise rule manifest.
+ *
+ * Single source of truth for every deterministic spec-reshape rule
+ * applied between analyse (faithful extraction) and inference. Mirrors
+ * the realize-rules manifest pattern (see `engines/src/realize/realize-rules.ts`):
+ * one declaration per rule, three consumers (runner, per-rule corpus,
+ * project-override loader).
+ *
+ * Phase 1a (engines 6.49.x) of the 2026-05-13-NORMALISE-PHASE proposal —
+ * INFRASTRUCTURE only. The RULES array is empty in this phase; the
+ * runner, manifest interface, and tests land first. Real rules
+ * (`cluster-module-functions`, `crud-into-curved`,
+ * `drop-trivial-passthrough`) land in Phase 2+.
+ *
+ * Why in engines/src/normalise/ (a new subsystem):
+ *   Normalise is its own phase between analyse and inference, with its
+ *   own pluggable rule set. Putting it under realize/ would conflate
+ *   two different rule-classes (one for post-LLM-emit validation, one
+ *   for pre-realize spec reshape). Following the entity-module
+ *   colocation principle (R12), normalise gets its own home.
+ */
+import { CLUSTER_MODULE_FUNCTIONS_RULE } from './rules/cluster-module-functions.js';
+import { CRUD_INTO_CURVED_RULE } from './rules/crud-into-curved.js';
+import { DROP_TRIVIAL_PASSTHROUGH_RULE } from './rules/drop-trivial-passthrough.js';
+/**
+ * The canonical rule manifest. Append rules as they land. Order in
+ * the array is informational only — the runner sorts by `ordering`.
+ *
+ * Phase 2 of `2026-05-13-NORMALISE-PHASE.md` §5:
+ *   - `cluster-module-functions` (ordering 0): strip project-prefix
+ *     from services synthesised by the module-functions adapter.
+ *
+ * Remaining rules (Phase 3-4 in §5):
+ *   - `crud-into-curved`: collapse Service ops 1:1 with CURVED to entity
+ *   - `drop-trivial-passthrough`: drop single-delegate-call ops
+ */
+export const RULES = [
+    CLUSTER_MODULE_FUNCTIONS_RULE,
+    CRUD_INTO_CURVED_RULE,
+    DROP_TRIVIAL_PASSTHROUGH_RULE,
+];
+/**
+ * Filter the manifest to rules applicable in `ctx`. Applies the
+ * standard inclusion logic in one place:
+ *
+ *   1. `disabledRules` in ctx wins — always skip.
+ *   2. `enabledByDefault: true` AND not in disabledRules → include.
+ *   3. `enabledByDefault: false` AND id is in enabledRules → include.
+ *   4. `appliesWhen` (when present) must return true.
+ *
+ * Returned rules are sorted by `ordering` ascending.
+ */
+export function rulesApplicableTo(ctx) {
+    const disabled = ctx.disabledRules ?? new Set();
+    const enabled = ctx.enabledRules ?? new Set();
+    return RULES
+        .filter((r) => {
+        if (disabled.has(r.id))
+            return false;
+        const enabledByConfig = r.enabledByDefault || enabled.has(r.id);
+        if (!enabledByConfig)
+            return false;
+        if (r.appliesWhen && !r.appliesWhen(ctx))
+            return false;
+        return true;
+    })
+        .slice()
+        .sort((a, b) => a.ordering - b.ordering);
+}
+/**
+ * Find a rule by id. Returns undefined when no rule with that id is
+ * registered. Used by tests, project-override loaders, audit-trail
+ * emission.
+ */
+export function getRule(id) {
+    return RULES.find((r) => r.id === id);
+}
+//# sourceMappingURL=normalise-rules.js.map

package/dist/normalise/normalise-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalise-rules.js","sourceRoot":"","sources":["../../src/normalise/normalise-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AAoIpF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,KAAK,GAAoB;IACpC,6BAA6B;IAC7B,qBAAqB;IACrB,6BAA6B;CAC9B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,QAAQ,GAAG,GAAG,CAAC,aAAa,IAAI,IAAI,GAAG,EAAU,CAAC;IACxD,MAAM,OAAO,GAAG,GAAG,CAAC,YAAY,IAAI,IAAI,GAAG,EAAU,CAAC;IACtD,OAAO,KAAK;SACT,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QACZ,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAAE,OAAO,KAAK,CAAC;QACrC,MAAM,eAAe,GAAG,CAAC,CAAC,gBAAgB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe;YAAE,OAAO,KAAK,CAAC;QACnC,IAAI,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;SACD,KAAK,EAAE;SACP,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,EAAU;IAChC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACxC,CAAC"}

package/dist/normalise/rules/cluster-module-functions.d.ts

@@ -0,0 +1,31 @@
+import type { NormaliseRule } from '../normalise-rules.js';
+interface ClusterMatchData {
+    componentName: string;
+    oldServiceName: string;
+    newServiceName: string;
+    prefix: string;
+    /** Map from old operation key to new operation key. */
+    opRenames: Map<string, string>;
+}
+/**
+ * Find the longest lowercase prefix shared by `names`, ending strictly
+ * before the first uppercase letter (camelCase boundary). Returns the
+ * empty string when no such prefix is found.
+ */
+declare function findCamelPrefix(names: string[]): string;
+declare function stripCamelPrefix(name: string, prefix: string): string;
+declare function stripPascalPrefix(serviceName: string, prefix: string): string | null;
+/**
+ * Detect whether the service with `serviceName` is a cluster-cleanup
+ * candidate. See file-header doc for the two detection signals.
+ */
+declare function detectClusterMatch(componentName: string, serviceName: string, serviceBody: Record<string, unknown>): ClusterMatchData | null;
+export declare const CLUSTER_MODULE_FUNCTIONS_RULE: NormaliseRule;
+export declare const __internal: {
+    findCamelPrefix: typeof findCamelPrefix;
+    stripCamelPrefix: typeof stripCamelPrefix;
+    stripPascalPrefix: typeof stripPascalPrefix;
+    detectClusterMatch: typeof detectClusterMatch;
+};
+export {};
+//# sourceMappingURL=cluster-module-functions.d.ts.map

package/dist/normalise/rules/cluster-module-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-module-functions.d.ts","sourceRoot":"","sources":["../../../src/normalise/rules/cluster-module-functions.ts"],"names":[],"mappings":"AA6DA,OAAO,KAAK,EACV,aAAa,EAId,MAAM,uBAAuB,CAAC;AAE/B,UAAU,gBAAgB;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;;;GAIG;AACH,iBAAS,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAYhD;AAED,iBAAS,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK9D;AAED,iBAAS,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ7E;AAED;;;GAGG;AACH,iBAAS,kBAAkB,CACzB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,gBAAgB,GAAG,IAAI,CAwDzB;AAkCD,eAAO,MAAM,6BAA6B,EAAE,aAuC3C,CAAC;AAGF,eAAO,MAAM,UAAU;;;;;CAKtB,CAAC"}

package/dist/normalise/rules/cluster-module-functions.js

@@ -0,0 +1,238 @@
+/**
+ * Normalise rule: `cluster-module-functions`.
+ *
+ * Phase 2 of the 2026-05-13-NORMALISE-PHASE proposal. Cleans up
+ * project-prefix noise on services synthesised by the module-functions
+ * adapter (Phase 0 prepass change).
+ *
+ * Trigger pattern: PowerSync / Drizzle / Supabase-queries codebases
+ * tend to prefix module functions with a project tag:
+ *
+ *   export async function smcCreateRound(...)
+ *   export async function smcGetRound(...)
+ *   export async function smcUpdateRoundStatus(...)
+ *
+ * The prepass synthesises one service per file. After Phase 0 the
+ * faithful spec looks like:
+ *
+ *   SmcRoundsService:
+ *     operations:
+ *       smcCreateRound: { ... }
+ *       smcGetRound: { ... }
+ *       smcUpdateRoundStatus: { ... }
+ *
+ * After this rule fires:
+ *
+ *   RoundsService:
+ *     operations:
+ *       createRound: { ... }
+ *       getRound: { ... }
+ *       updateRoundStatus: { ... }
+ *
+ * The `Smc` / `smc` project prefix appears on both the service name
+ * (PascalCase) and operation names (camelCase). Stripping it from both
+ * removes noise while preserving the rest of the naming so the LLM-
+ * authored bodies still reference the right entities.
+ *
+ * What this rule does NOT do (deferred to later rules):
+ *   - Rename service from `RoundsService` to `RoundService` based on
+ *     detected target entity (would be `cluster-module-functions`'s
+ *     dominant-entity inference, per proposal §5 — separate rule)
+ *   - Collapse `RoundsService.getRound` → `Round.retrieve` CURVED
+ *     (that's `crud-into-curved`, Rule 2)
+ *   - Drop trivial passthrough ops (Rule 3)
+ *
+ * Conservative invariants:
+ *   - Prefix must be 2–3 lowercase letters ending just before an
+ *     uppercase letter (camelCase boundary). The 3-char ceiling is the
+ *     load-bearing false-positive defence: real project tags are short
+ *     non-words (`smc`, `db`, `api`, `iam`); English verbs that share
+ *     a camelCase head (`save`, `claim`, `format`, `calculate`,
+ *     `invalidate`) are 4+ characters and stay untouched.
+ *   - At least ONE operation must share the prefix (no service-name-
+ *     only renames — `SaveGameService` doesn't get stripped to
+ *     `GameService` just because `Save` appears at the start of the
+ *     service name; that's a meaningful word, not a project tag).
+ *   - Skip when stripping would produce a name collision.
+ *   - Skip when stripping would produce an empty / invalid name.
+ *   - Skip when ctx.source === 'hand-authored'.
+ */
+const MAX_PREFIX_LENGTH = 3;
+/**
+ * Find the longest lowercase prefix shared by `names`, ending strictly
+ * before the first uppercase letter (camelCase boundary). Returns the
+ * empty string when no such prefix is found.
+ */
+function findCamelPrefix(names) {
+    if (names.length === 0)
+        return '';
+    const reference = names[0];
+    let candidate = '';
+    for (let i = 0; i < reference.length; i++) {
+        const c = reference[i];
+        if (c >= 'A' && c <= 'Z')
+            break;
+        if (!(c >= 'a' && c <= 'z'))
+            break;
+        if (!names.every((n) => n[i] === c))
+            break;
+        candidate += c;
+    }
+    return candidate;
+}
+function stripCamelPrefix(name, prefix) {
+    if (!name.startsWith(prefix))
+        return name;
+    const rest = name.slice(prefix.length);
+    if (rest.length === 0)
+        return name;
+    return rest[0].toLowerCase() + rest.slice(1);
+}
+function stripPascalPrefix(serviceName, prefix) {
+    if (prefix.length === 0)
+        return null;
+    const pascalPrefix = prefix[0].toUpperCase() + prefix.slice(1).toLowerCase();
+    if (!serviceName.startsWith(pascalPrefix))
+        return null;
+    const rest = serviceName.slice(pascalPrefix.length);
+    if (rest.length === 0)
+        return null;
+    if (!(rest[0] >= 'A' && rest[0] <= 'Z'))
+        return null;
+    return rest;
+}
+/**
+ * Detect whether the service with `serviceName` is a cluster-cleanup
+ * candidate. See file-header doc for the two detection signals.
+ */
+function detectClusterMatch(componentName, serviceName, serviceBody) {
+    const ops = serviceBody.operations;
+    if (!ops || typeof ops !== 'object')
+        return null;
+    const opNames = Object.keys(ops);
+    if (opNames.length === 0)
+        return null;
+    // Signal A — multi-operation common prefix.
+    let prefix = '';
+    if (opNames.length >= 2) {
+        prefix = findCamelPrefix(opNames);
+    }
+    // Signal B — service-name prefix matched by ≥1 op's camel prefix.
+    if ((prefix.length < 2 || prefix.length > MAX_PREFIX_LENGTH) && opNames.length >= 1) {
+        for (const op of opNames) {
+            const opPrefix = findCamelPrefix([op]);
+            if (opPrefix.length < 2 || opPrefix.length > MAX_PREFIX_LENGTH)
+                continue;
+            if (stripPascalPrefix(serviceName, opPrefix) !== null) {
+                prefix = opPrefix;
+                break;
+            }
+        }
+    }
+    // Length cap: project tags are short. Anything longer is an English
+    // verb like `save` / `claim` / `calculate` that we mustn't strip.
+    if (prefix.length < 2 || prefix.length > MAX_PREFIX_LENGTH)
+        return null;
+    // Compute the renames + check for collisions.
+    const opRenames = new Map();
+    const newNamesSeen = new Set();
+    for (const op of opNames) {
+        const newName = stripCamelPrefix(op, prefix);
+        if (newName === op)
+            continue;
+        if (newName.length === 0)
+            return null;
+        if (newNamesSeen.has(newName) || opNames.includes(newName))
+            return null;
+        opRenames.set(op, newName);
+        newNamesSeen.add(newName);
+    }
+    // Activity requirement: at least one operation must share the prefix.
+    // Without this, a service whose NAME happens to begin with a short
+    // lowercase word (`SaveGameService`, `IdpFooService`) would get
+    // renamed even when no operation evidence supports the prefix being
+    // a project tag.
+    if (opRenames.size === 0)
+        return null;
+    const newServiceName = stripPascalPrefix(serviceName, prefix);
+    return {
+        componentName,
+        oldServiceName: serviceName,
+        newServiceName: newServiceName ?? serviceName,
+        prefix,
+        opRenames,
+    };
+}
+function applyClusterMatch(spec, data) {
+    const components = spec.components;
+    const component = components?.[data.componentName];
+    const services = component?.services;
+    if (!services)
+        return spec;
+    const serviceBody = services[data.oldServiceName];
+    if (!serviceBody)
+        return spec;
+    // Rename operations preserving insertion order.
+    const oldOps = serviceBody.operations;
+    const renamedOps = {};
+    for (const [oldKey, value] of Object.entries(oldOps)) {
+        const newKey = data.opRenames.get(oldKey) ?? oldKey;
+        renamedOps[newKey] = value;
+    }
+    serviceBody.operations = renamedOps;
+    // Rename service key if changed. We need to preserve insertion order
+    // here too — rebuild the services object with the renamed key in the
+    // original slot.
+    if (data.newServiceName !== data.oldServiceName) {
+        const rebuilt = {};
+        for (const [k, v] of Object.entries(services)) {
+            if (k === data.oldServiceName)
+                rebuilt[data.newServiceName] = v;
+            else
+                rebuilt[k] = v;
+        }
+        component.services = rebuilt;
+    }
+    return spec;
+}
+export const CLUSTER_MODULE_FUNCTIONS_RULE = {
+    id: 'cluster-module-functions',
+    summary: 'Strip project-prefix from synthesised module-function services + their operations (e.g. SmcRoundsService.smcGetRound → RoundsService.getRound).',
+    ordering: 0,
+    enabledByDefault: true,
+    appliesWhen: (ctx) => ctx.source !== 'hand-authored',
+    detect: (spec) => {
+        const matches = [];
+        const components = spec.components;
+        if (!components || typeof components !== 'object')
+            return matches;
+        for (const [componentName, componentBody] of Object.entries(components)) {
+            const services = componentBody?.services;
+            if (!services || typeof services !== 'object')
+                continue;
+            for (const [serviceName, serviceBody] of Object.entries(services)) {
+                if (!serviceBody || typeof serviceBody !== 'object')
+                    continue;
+                const data = detectClusterMatch(componentName, serviceName, serviceBody);
+                if (!data)
+                    continue;
+                matches.push({
+                    description: `${componentName}.${serviceName}: strip prefix "${data.prefix}" — ${data.opRenames.size} operation(s) renamed${data.newServiceName !== serviceName ? `, service → ${data.newServiceName}` : ''}`,
+                    data,
+                });
+            }
+        }
+        return matches;
+    },
+    transform: (spec, match) => {
+        return applyClusterMatch(spec, match.data);
+    },
+};
+// Internal helpers exported for unit testing.
+export const __internal = {
+    findCamelPrefix,
+    stripCamelPrefix,
+    stripPascalPrefix,
+    detectClusterMatch,
+};
+//# sourceMappingURL=cluster-module-functions.js.map

package/dist/normalise/rules/cluster-module-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-module-functions.js","sourceRoot":"","sources":["../../../src/normalise/rules/cluster-module-functions.ts"],"names":[],"mappings":"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"}

package/dist/normalise/rules/crud-into-curved.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Normalise rule: `crud-into-curved`.
+ *
+ * Phase 3 of `2026-05-13-NORMALISE-PHASE.md` §5 Rule 2. Lifts Service
+ * operations that match the canonical CRUD shape onto their target
+ * entity's Controller `cured:` block. This eliminates redundant service
+ * shells for plain CRUD wrappers — SpecVerse generates
+ * `cured.retrieve/create/update/delete` from a controller's cured
+ * declaration, so an explicit `Service.getClub` that just does
+ * "look up by id" is duplicating convention.
+ *
+ * Schema note: CURVED operations live on Controllers, NOT on Models.
+ * If the target entity has no Controller declared, the rule synthesises
+ * a `<Entity>Controller` (with `model: <Entity>`) in the same component
+ * as the Model. The cured op lands there.
+ *
+ * Before (post-Rule-1 / cluster-module-functions):
+ *
+ *   components:
+ *     App:
+ *       models:
+ *         Club:
+ *           attributes: [...]
+ *       services:
+ *         ClubsService:
+ *           operations:
+ *             getClub:
+ *               steps: [Look up Club by id, Return Club or null]
+ *               requires: [id is provided]
+ *             getClubPositions:                 # NOT lifted (filtered query)
+ *               steps: [...]
+ *
+ * After:
+ *
+ *   components:
+ *     App:
+ *       models:
+ *         Club:
+ *           attributes: [...]
+ *       controllers:
+ *         ClubController:                       # synthesised by this rule
+ *           model: Club
+ *           cured:
+ *             retrieve:
+ *               steps: [Look up Club by id, Return Club or null]
+ *               requires: [id is provided]
+ *       services:
+ *         ClubsService:
+ *           operations:
+ *             getClubPositions: { ... }        # remains
+ *
+ * If the service becomes empty after lifting, it is dropped entirely.
+ *
+ * Conservative matching:
+ *   - Op name must be EXACTLY `<verb><EntityName>` — no trailing suffix
+ *     (`getRound` ✓, `getRoundsForUser` ✗, `getRoundStatus` ✗)
+ *   - Target Entity name must resolve UNIQUELY to ONE model across all
+ *     components (the cured block goes to whichever component the model
+ *     lives in — cross-component lifts are fine since the cured: lives
+ *     ON the model, not at the service site)
+ *   - Skip when the entity name is declared in multiple components (rare,
+ *     but ambiguous — caller can rename the duplicate)
+ *   - Target model's `cured.<curvedOp>` must NOT already be declared
+ *     (don't overwrite spec-author intent)
+ *   - Verb patterns recognised:
+ *       get / retrieve / find → retrieve
+ *       create / add          → create   (Phase 3: only `create` to stay safe)
+ *       update                → update
+ *       delete / remove       → delete   (Phase 3: only `delete` to stay safe)
+ *
+ * NOT in Phase 3 scope:
+ *   - retrieve_many (list / getAll / search — naming varies too widely)
+ *   - Evolve transitions (would need lifecycle state-machine signal)
+ *   - Cross-component lifts (target model in a different component)
+ *   - Multi-arg create variants (createClubWithPositions)
+ */
+import type { NormaliseRule, NormaliseSpec } from '../normalise-rules.js';
+interface CrudMatchData {
+    /** Component hosting the source Service. */
+    sourceComponentName: string;
+    /** Component hosting the target Model (may differ from source). */
+    targetComponentName: string;
+    modelName: string;
+    serviceName: string;
+    operationName: string;
+    curvedOp: 'retrieve' | 'create' | 'update' | 'delete';
+}
+/**
+ * Parse an operation name into (verb, entityName) if it matches the
+ * exact `<verb><PascalCaseEntity>` shape. Returns null otherwise.
+ *
+ * The entity portion must be PascalCase, contain no further uppercase
+ * boundaries after the leading letter (i.e. single PascalCase word),
+ * AND must end at the end of the string (no trailing qualifier like
+ * `getRoundStatus` or `getClubsForUser`).
+ */
+declare function parseCrudOpName(opName: string): {
+    verb: string;
+    curved: CrudMatchData['curvedOp'];
+    entity: string;
+} | null;
+/**
+ * Build a model-name → component-name index across all components. Used
+ * by the cross-component target lookup. When an entity name is declared
+ * in multiple components, it's recorded as ambiguous (the rule then
+ * skips matches against that name).
+ */
+declare function buildModelIndex(spec: NormaliseSpec): Map<string, string | 'ambiguous'>;
+declare function detectMatchesInComponent(spec: NormaliseSpec, modelIndex: Map<string, string | 'ambiguous'>, componentName: string, componentBody: Record<string, unknown>): CrudMatchData[];
+export declare const CRUD_INTO_CURVED_RULE: NormaliseRule;
+export declare const __internal: {
+    parseCrudOpName: typeof parseCrudOpName;
+    buildModelIndex: typeof buildModelIndex;
+    detectMatchesInComponent: typeof detectMatchesInComponent;
+};
+export {};
+//# sourceMappingURL=crud-into-curved.d.ts.map

package/dist/normalise/rules/crud-into-curved.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud-into-curved.d.ts","sourceRoot":"","sources":["../../../src/normalise/rules/crud-into-curved.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH,OAAO,KAAK,EACV,aAAa,EAGb,aAAa,EACd,MAAM,uBAAuB,CAAC;AAE/B,UAAU,aAAa;IACrB,4CAA4C;IAC5C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;CACvD;AAYD;;;;;;;;GAQG;AACH,iBAAS,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoBnH;AAED;;;;;GAKG;AACH,iBAAS,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,CAgB/E;AAED,iBAAS,wBAAwB,CAC/B,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,EAC7C,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,aAAa,EAAE,CAuCjB;AAmFD,eAAO,MAAM,qBAAqB,EAAE,aAmCnC,CAAC;AAEF,eAAO,MAAM,UAAU;;;;CAItB,CAAC"}