@specverse/engines 6.42.3 → 6.53.1

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"}

package/dist/normalise/rules/crud-into-curved.js

@@ -0,0 +1,303 @@
+/**
+ * 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)
+ */
+/** Verb → CURVED op mapping. Order matters for prefix matching (longer first). */
+const VERB_MAP = [
+    { verb: 'retrieve', curved: 'retrieve' },
+    { verb: 'create', curved: 'create' },
+    { verb: 'update', curved: 'update' },
+    { verb: 'delete', curved: 'delete' },
+    { verb: 'find', curved: 'retrieve' },
+    { verb: 'get', curved: 'retrieve' },
+];
+/**
+ * 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`).
+ */
+function parseCrudOpName(opName) {
+    for (const { verb, curved } of VERB_MAP) {
+        if (!opName.startsWith(verb))
+            continue;
+        const rest = opName.slice(verb.length);
+        if (rest.length === 0)
+            continue;
+        // First character must be uppercase (start of entity name).
+        if (!(rest[0] >= 'A' && rest[0] <= 'Z'))
+            continue;
+        // Rest must be a SINGLE PascalCase word — no further capital letters
+        // after the first character. This rules out compound names like
+        // `getClubPositions` (Positions is a 2nd PascalCase token →
+        // domain-filtered query, NOT plain retrieve).
+        let hasSecondCapital = false;
+        for (let i = 1; i < rest.length; i++) {
+            const c = rest[i];
+            if (c >= 'A' && c <= 'Z') {
+                hasSecondCapital = true;
+                break;
+            }
+        }
+        if (hasSecondCapital)
+            continue;
+        return { verb, curved, entity: rest };
+    }
+    return 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).
+ */
+function buildModelIndex(spec) {
+    const out = new Map();
+    const components = spec.components;
+    if (!components)
+        return out;
+    for (const [componentName, componentBody] of Object.entries(components)) {
+        const models = componentBody?.models;
+        if (!models)
+            continue;
+        for (const modelName of Object.keys(models)) {
+            const existing = out.get(modelName);
+            if (existing === undefined)
+                out.set(modelName, componentName);
+            else if (existing !== componentName)
+                out.set(modelName, 'ambiguous');
+        }
+    }
+    return out;
+}
+function detectMatchesInComponent(spec, modelIndex, componentName, componentBody) {
+    const out = [];
+    const services = componentBody.services;
+    if (!services)
+        return out;
+    for (const [serviceName, serviceBody] of Object.entries(services)) {
+        if (!serviceBody || typeof serviceBody !== 'object')
+            continue;
+        const ops = serviceBody.operations;
+        if (!ops || typeof ops !== 'object')
+            continue;
+        for (const opName of Object.keys(ops)) {
+            const parsed = parseCrudOpName(opName);
+            if (!parsed)
+                continue;
+            const targetComponent = modelIndex.get(parsed.entity);
+            if (!targetComponent || targetComponent === 'ambiguous')
+                continue;
+            // Look up the target controller's cured block (if a controller
+            // already exists for this model). Skip if the op is already
+            // declared. Controllers may be missing — that's fine; the
+            // transform will synthesise one.
+            const components = spec.components;
+            const targetComponentBody = components[targetComponent];
+            const existingController = findControllerForModel(targetComponentBody, parsed.entity);
+            if (existingController) {
+                const existingCured = existingController.cured;
+                if (existingCured && parsed.curved in existingCured)
+                    continue;
+            }
+            out.push({
+                sourceComponentName: componentName,
+                targetComponentName: targetComponent,
+                modelName: parsed.entity,
+                serviceName,
+                operationName: opName,
+                curvedOp: parsed.curved,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Find the controller in `componentBody` whose `model:` field references
+ * the given entity name. Returns the controller body, or null if none.
+ * The controller's KEY in the controllers object is the controller name
+ * (e.g. ClubController); the `model:` field declares which model it
+ * operates on.
+ */
+function findControllerForModel(componentBody, modelName) {
+    const controllers = componentBody.controllers;
+    if (!controllers || typeof controllers !== 'object')
+        return null;
+    for (const ctrlBody of Object.values(controllers)) {
+        if (!ctrlBody || typeof ctrlBody !== 'object')
+            continue;
+        if (ctrlBody.model === modelName) {
+            return ctrlBody;
+        }
+    }
+    return null;
+}
+function applyCrudMatch(spec, data) {
+    const components = spec.components;
+    const sourceComponent = components[data.sourceComponentName];
+    const targetComponent = components[data.targetComponentName];
+    const services = sourceComponent.services;
+    const serviceBody = services[data.serviceName];
+    const ops = serviceBody.operations;
+    const opBody = ops[data.operationName];
+    // Locate the target controller (synthesise one if absent).
+    let targetController = findControllerForModel(targetComponent, data.modelName);
+    let targetControllerName = null;
+    if (!targetController) {
+        targetControllerName = `${data.modelName}Controller`;
+        targetController = { model: data.modelName };
+        // Insert into the component's controllers map. Create the map if
+        // it doesn't exist (preserving the standard position in the
+        // component — models then controllers then services).
+        const existingControllers = targetComponent.controllers ?? {};
+        existingControllers[targetControllerName] = targetController;
+        targetComponent.controllers = existingControllers;
+    }
+    else {
+        // Find the key of the existing controller (we have its body, need its name for description).
+        const allControllers = targetComponent.controllers;
+        for (const [k, v] of Object.entries(allControllers)) {
+            if (v === targetController) {
+                targetControllerName = k;
+                break;
+            }
+        }
+    }
+    // Insert under controller.cured.<curvedOp>. Preserve standard order.
+    const existingCured = targetController.cured ?? {};
+    const newCured = {};
+    const STANDARD_ORDER = ['create', 'update', 'retrieve', 'retrieve_many', 'validate', 'evolve', 'delete'];
+    const allKeys = new Set([...Object.keys(existingCured), data.curvedOp]);
+    for (const k of STANDARD_ORDER) {
+        if (allKeys.has(k)) {
+            newCured[k] = k === data.curvedOp ? opBody : existingCured[k];
+        }
+    }
+    for (const [k, v] of Object.entries(existingCured)) {
+        if (!STANDARD_ORDER.includes(k))
+            newCured[k] = v;
+    }
+    targetController.cured = newCured;
+    // Remove operation from service.
+    delete ops[data.operationName];
+    // If the service has no remaining operations, drop the service. If
+    // doing so leaves an empty services map, drop that too.
+    if (Object.keys(ops).length === 0) {
+        delete services[data.serviceName];
+        if (Object.keys(services).length === 0) {
+            delete sourceComponent.services;
+        }
+    }
+    return spec;
+}
+export const CRUD_INTO_CURVED_RULE = {
+    id: 'crud-into-curved',
+    summary: 'Lift Service operations matching <verb><Entity> exactly (where Entity is a model in the same component) to the model\'s cured: block. Drop service if empty.',
+    ordering: 10,
+    enabledByDefault: true,
+    appliesWhen: (ctx) => ctx.source !== 'hand-authored',
+    detect: (spec) => {
+        const matches = [];
+        const components = spec.components;
+        if (!components || typeof components !== 'object')
+            return matches;
+        const modelIndex = buildModelIndex(spec);
+        for (const [componentName, componentBody] of Object.entries(components)) {
+            if (!componentBody || typeof componentBody !== 'object')
+                continue;
+            const found = detectMatchesInComponent(spec, modelIndex, componentName, componentBody);
+            for (const data of found) {
+                const crossComp = data.sourceComponentName !== data.targetComponentName;
+                matches.push({
+                    description: `${data.sourceComponentName}.${data.serviceName}.${data.operationName} → ${data.targetComponentName}.${data.modelName}.cured.${data.curvedOp}${crossComp ? ' (cross-component)' : ''}`,
+                    data,
+                });
+            }
+        }
+        return matches;
+    },
+    transform: (spec, match) => {
+        return applyCrudMatch(spec, match.data);
+    },
+};
+export const __internal = {
+    parseCrudOpName,
+    buildModelIndex,
+    detectMatchesInComponent,
+};
+//# sourceMappingURL=crud-into-curved.js.map