@intentius/chant 0.124.13 → 0.124.15

package/dist/lint/rules/comp/support.js

@@ -0,0 +1,129 @@
+/**
+ * Shared walking/wiring helpers for the COMP* composition rules (#562, epic
+ * #551). Every COMP rule operates over the real, discovered `Component`
+ * graph (see ../../component-checks.ts), not raw TypeScript source — these
+ * helpers flatten a component's `deploy`/`rollback` phases into steps and
+ * parse the wiring reference forms `../../../components/driver.ts` already
+ * resolves at runtime, so lint can check the same references before
+ * anything runs (per docs/components/orchestration.mdx).
+ */
+/** True if a step/gate/nested-phase entry is a `Gate` (`kind: "gate"`). */
+export function isGateEntry(entry) {
+    return entry.kind === "gate";
+}
+/** True if a step/gate/nested-phase entry is itself a nested `Phase` (a fan-out unit) — see `component.ts`'s `isNestedPhase`. */
+export function isPhaseEntry(entry) {
+    return typeof entry.phase === "string" && Array.isArray(entry.steps);
+}
+/** True if a step/gate/nested-phase entry is a plain capability `Step` (neither a gate nor a nested phase). */
+export function isStepEntry(entry) {
+    return !isGateEntry(entry) && !isPhaseEntry(entry);
+}
+/**
+ * Flatten every step and gate across a list of phases (including nested
+ * fan-out phases and `onFailure` compensation phases), matching
+ * `component.ts`'s own `allSteps` walk but keeping the immediate phase
+ * alongside each entry (needed for `@Phase.field` reference checks and for
+ * "same phase" sibling checks) and separating gates out explicitly.
+ */
+export function walkPhases(phases) {
+    const steps = [];
+    const gates = [];
+    const walk = (ps) => {
+        for (const p of ps) {
+            for (const entry of p.steps) {
+                if (isPhaseEntry(entry)) {
+                    walk([entry]);
+                }
+                else if (isGateEntry(entry)) {
+                    gates.push({ gate: entry, phaseName: p.phase, phase: p });
+                }
+                else {
+                    steps.push({ step: entry, phaseName: p.phase, phase: p });
+                }
+            }
+            if (p.onFailure)
+                walk(p.onFailure);
+        }
+    };
+    walk(phases ?? []);
+    return { steps, gates };
+}
+/** Every step and gate across a component's `deploy` plus its top-level `rollback` phases. */
+export function walkComponent(component) {
+    const deployWalk = walkPhases(component.deploy);
+    const rollbackWalk = walkPhases(component.rollback);
+    return {
+        steps: [...deployWalk.steps, ...rollbackWalk.steps],
+        gates: [...deployWalk.gates, ...rollbackWalk.gates],
+    };
+}
+/** Every distinct phase name declared directly in a component's `deploy` (top-level only, not nested fan-out phase names — those are addressed by the fan-out's own phase name, never the parent's). */
+export function topLevelPhaseNames(component) {
+    return new Set((component.deploy ?? []).map((p) => p.phase));
+}
+// ── Wiring reference parsing (mirrors ../../../components/driver.ts) ────────
+/** `@Phase.field[...]` — a prior step's output within the same component, keyed by phase name. */
+const PRIOR_STEP_REF = /^@([A-Za-z0-9_ ]+)\.([A-Za-z0-9_.]+)$/;
+/** `@<component>.publish.uri|digest|key` — a cross-component artifact reference. */
+const COMPONENT_ARTIFACT_REF = /^@([a-z0-9]+(?:-[a-z0-9]+)*)\.publish\.(uri|digest|key)$/;
+/** Parse a single string value as one of the two name-bearing wiring reference forms (`@Phase.field`, `@component.publish.*`). Returns `undefined` for a plain literal, an `$env.*` reference, or a malformed `@` reference (schema validation, not lint, is responsible for rejecting malformed references). */
+export function parseWiringRef(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const artifactMatch = value.match(COMPONENT_ARTIFACT_REF);
+    if (artifactMatch) {
+        return { kind: "component-artifact", componentName: artifactMatch[1], field: artifactMatch[2] };
+    }
+    const priorStepMatch = value.match(PRIOR_STEP_REF);
+    if (priorStepMatch) {
+        return { kind: "prior-step", phaseName: priorStepMatch[1], field: priorStepMatch[2] };
+    }
+    return undefined;
+}
+/** Recursively collect every wiring-reference-shaped string found anywhere in a step's fields (imageRef, jar, revision, inputs, and any other open capability-specific property), matching how ../../../components/driver.ts's `resolveStepInput` walks a step's input. */
+export function collectWiringRefs(step) {
+    const refs = [];
+    const walk = (value) => {
+        if (typeof value === "string") {
+            const ref = parseWiringRef(value);
+            if (ref)
+                refs.push(ref);
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const v of value)
+                walk(v);
+            return;
+        }
+        if (value && typeof value === "object") {
+            // `{ stackOutput: { stack, name } }` is a cross-stack reference, resolved
+            // by the graph, not a same-project component/phase reference — out of
+            // scope for this reference check (see component-contract.mdx).
+            if ("stackOutput" in value)
+                return;
+            for (const v of Object.values(value))
+                walk(v);
+        }
+    };
+    const { kind: _kind, ...rest } = step;
+    walk(rest);
+    return refs;
+}
+/** A structural fingerprint of a component's composition shape, ignoring `name`/`dependsOn`/wiring literal values — two components with the same fingerprint compose the exact same phase/step-kind shape (see COMP007, "identical composition repeated across components"). */
+export function compositionFingerprint(component) {
+    const shape = (component.deploy ?? []).map((p) => fingerprintPhase(p));
+    return JSON.stringify(shape);
+}
+function fingerprintPhase(phase) {
+    return {
+        parallel: phase.parallel ?? false,
+        steps: phase.steps.map((entry) => {
+            if (isPhaseEntry(entry))
+                return fingerprintPhase(entry);
+            if (isGateEntry(entry))
+                return { kind: "gate" };
+            return { kind: entry.kind };
+        }),
+    };
+}

package/dist/lint/rules/composite-scope.js

@@ -0,0 +1,51 @@
+import * as ts from "typescript";
+/**
+ * Check if a node is inside a Composite() factory callback.
+ *
+ * Composite factories define parameterized resource groups where dynamic
+ * expressions, spreads, and inline objects are expected. Lint rules that
+ * enforce static declarations should skip nodes inside these callbacks.
+ *
+ * Matches: Composite((props) => { ... }) and _.Composite((props) => { ... })
+ */
+export function isInsideCompositeFactory(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
+            const parent = current.parent;
+            if (parent && ts.isCallExpression(parent) && parent.arguments[0] === current) {
+                const callee = parent.expression;
+                if (isCompositeCallee(callee)) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * If the given CallExpression is a Composite() call, return its factory argument.
+ * Returns undefined if not a Composite call or factory is missing.
+ */
+export function getCompositeFactory(call) {
+    if (!isCompositeCallee(call.expression))
+        return undefined;
+    const factory = call.arguments[0];
+    if (!factory)
+        return undefined;
+    if (ts.isArrowFunction(factory) || ts.isFunctionExpression(factory))
+        return factory;
+    return undefined;
+}
+export function isCompositeCallee(node) {
+    // Composite(...)
+    if (ts.isIdentifier(node) && node.text === "Composite") {
+        return true;
+    }
+    // _.Composite(...) or anything.Composite(...)
+    if (ts.isPropertyAccessExpression(node) && node.name.text === "Composite") {
+        return true;
+    }
+    return false;
+}

package/dist/lint/rules/cor017-composite-name-match.js

@@ -0,0 +1,93 @@
+import * as ts from "typescript";
+import { isCompositeCallee } from "./composite-scope.js";
+/**
+ * COR017: Composite name must match variable name
+ *
+ * The second argument to Composite() (the name string) must match the
+ * const variable it's assigned to. This name is used in resource expansion
+ * (e.g. healthApiRole, healthApiFunc) and in error messages.
+ *
+ * Triggers on: const LambdaApi = Composite(fn, "MyFunction")  — mismatch
+ * Triggers on: const LambdaApi = Composite(fn)                — missing name
+ * OK: const LambdaApi = Composite(fn, "LambdaApi")
+ */
+function checkNode(node, context, diagnostics) {
+    if (ts.isVariableDeclaration(node) && node.initializer && ts.isCallExpression(node.initializer)) {
+        const call = node.initializer;
+        if (!isCompositeCallee(call.expression)) {
+            ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+            return;
+        }
+        // Get the variable name
+        if (!ts.isIdentifier(node.name)) {
+            ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+            return;
+        }
+        const variableName = node.name.text;
+        // Check second argument
+        const nameArg = call.arguments[1];
+        if (!nameArg) {
+            // Missing name argument
+            const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(call.expression.getStart(context.sourceFile));
+            // Insert fix: add name argument after the factory callback
+            const factoryArg = call.arguments[0];
+            const insertPos = factoryArg.getEnd();
+            diagnostics.push({
+                file: context.filePath,
+                line: line + 1,
+                column: character + 1,
+                ruleId: "COR017",
+                severity: "error",
+                message: `Composite is missing a name argument — add "${variableName}" as the second argument`,
+                fix: {
+                    range: [insertPos, insertPos],
+                    replacement: `, "${variableName}"`,
+                },
+            });
+        }
+        else if (!ts.isStringLiteral(nameArg)) {
+            // Non-literal name argument
+            const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(nameArg.getStart(context.sourceFile));
+            diagnostics.push({
+                file: context.filePath,
+                line: line + 1,
+                column: character + 1,
+                ruleId: "COR017",
+                severity: "error",
+                message: `Composite name must be a string literal`,
+                fix: {
+                    range: [nameArg.getStart(context.sourceFile), nameArg.getEnd()],
+                    replacement: `"${variableName}"`,
+                },
+            });
+        }
+        else if (nameArg.text !== variableName) {
+            // Name mismatch
+            const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(nameArg.getStart(context.sourceFile));
+            diagnostics.push({
+                file: context.filePath,
+                line: line + 1,
+                column: character + 1,
+                ruleId: "COR017",
+                severity: "error",
+                message: `Composite name "${nameArg.text}" does not match variable name "${variableName}"`,
+                fix: {
+                    range: [nameArg.getStart(context.sourceFile), nameArg.getEnd()],
+                    replacement: `"${variableName}"`,
+                },
+            });
+        }
+    }
+    ts.forEachChild(node, (child) => checkNode(child, context, diagnostics));
+}
+export const cor017CompositeNameMatchRule = {
+    id: "COR017",
+    severity: "error",
+    category: "correctness",
+    description: "Composite name argument must match the variable it is assigned to",
+    check(context) {
+        const diagnostics = [];
+        checkNode(context.sourceFile, context, diagnostics);
+        return diagnostics;
+    },
+};

package/dist/lint/rules/cor018-composite-prefer-lexicon-type.js

@@ -0,0 +1,136 @@
+import * as ts from "typescript";
+import { isCompositeCallee } from "./composite-scope.js";
+/**
+ * COR018: Prefer lexicon property types in Composite props
+ *
+ * Composite prop interfaces should use lexicon property types (via the lexicon package)
+ * instead of locally-declared interfaces or type aliases. Local types next to
+ * a Composite definition often duplicate existing lexicon property types.
+ *
+ * Triggers on: interface with fields used as a Composite prop type, declared
+ *              in the same file as the Composite (excluding the props interface itself)
+ * OK: InstanceType<typeof _.Role_Policy>
+ * OK: primitives (string, number, boolean)
+ * OK: lexicon-imported types
+ */
+/**
+ * Find all Composite() calls and extract their props type names.
+ */
+function findCompositePropsTypes(sourceFile) {
+    const propsTypes = new Set();
+    function walk(node) {
+        if (ts.isCallExpression(node) && isCompositeCallee(node.expression)) {
+            // Composite<PropsType>(...) — extract from type arguments
+            if (node.typeArguments && node.typeArguments.length > 0) {
+                const typeArg = node.typeArguments[0];
+                if (ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName)) {
+                    propsTypes.add(typeArg.typeName.text);
+                }
+            }
+        }
+        ts.forEachChild(node, walk);
+    }
+    walk(sourceFile);
+    return propsTypes;
+}
+/**
+ * Find all locally-declared interface and type alias names.
+ */
+function findLocalTypeDeclarations(sourceFile) {
+    const types = new Map();
+    function walk(node) {
+        if (ts.isInterfaceDeclaration(node)) {
+            types.set(node.name.text, node);
+        }
+        else if (ts.isTypeAliasDeclaration(node)) {
+            types.set(node.name.text, node);
+        }
+        ts.forEachChild(node, walk);
+    }
+    walk(sourceFile);
+    return types;
+}
+/**
+ * Collect type references used in a props interface's field types.
+ * Returns names of locally-referenced types (not primitives, not from the lexicon package).
+ */
+function collectFieldTypeRefs(propsDecl, localTypes) {
+    const refs = new Map();
+    if (!ts.isInterfaceDeclaration(propsDecl))
+        return refs;
+    for (const member of propsDecl.members) {
+        if (!ts.isPropertySignature(member) || !member.type)
+            continue;
+        const fieldName = ts.isIdentifier(member.name) ? member.name.text : "<computed>";
+        collectTypeRefsFromNode(member.type, localTypes, fieldName, refs);
+    }
+    return refs;
+}
+function collectTypeRefsFromNode(node, localTypes, fieldName, refs) {
+    if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+        const name = node.typeName.text;
+        if (localTypes.has(name) && !refs.has(name)) {
+            refs.set(name, { fieldName, typeNode: node });
+        }
+    }
+    // Recurse into array types: CustomType[] → CustomType
+    if (ts.isArrayTypeNode(node)) {
+        collectTypeRefsFromNode(node.elementType, localTypes, fieldName, refs);
+    }
+    // Recurse into union/intersection types
+    if (ts.isUnionTypeNode(node) || ts.isIntersectionTypeNode(node)) {
+        for (const member of node.types) {
+            collectTypeRefsFromNode(member, localTypes, fieldName, refs);
+        }
+    }
+    // Recurse into generic type arguments
+    if (ts.isTypeReferenceNode(node) && node.typeArguments) {
+        for (const arg of node.typeArguments) {
+            collectTypeRefsFromNode(arg, localTypes, fieldName, refs);
+        }
+    }
+}
+function checkFile(context) {
+    const diagnostics = [];
+    const { sourceFile } = context;
+    // Find Composite calls and their props types
+    const propsTypeNames = findCompositePropsTypes(sourceFile);
+    if (propsTypeNames.size === 0)
+        return diagnostics;
+    // Find all local type declarations
+    const localTypes = findLocalTypeDeclarations(sourceFile);
+    for (const propsTypeName of propsTypeNames) {
+        const propsDecl = localTypes.get(propsTypeName);
+        if (!propsDecl)
+            continue;
+        // Find local types referenced in the props fields
+        // Exclude the props interface itself
+        const otherLocalTypes = new Map(localTypes);
+        otherLocalTypes.delete(propsTypeName);
+        if (otherLocalTypes.size === 0)
+            continue;
+        const fieldRefs = collectFieldTypeRefs(propsDecl, otherLocalTypes);
+        for (const [typeName, { fieldName, typeNode }] of fieldRefs) {
+            const typeDecl = localTypes.get(typeName);
+            const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(typeDecl.getStart(context.sourceFile));
+            diagnostics.push({
+                file: context.filePath,
+                line: line + 1,
+                column: character + 1,
+                ruleId: "COR018",
+                severity: "info",
+                message: `Local type "${typeName}" is used in Composite prop "${fieldName}" — consider using a lexicon property type instead (e.g., InstanceType<typeof _.PropertyType>)`,
+            });
+        }
+    }
+    return diagnostics;
+}
+export const cor018CompositePreferLexiconTypeRule = {
+    id: "COR018",
+    severity: "info",
+    category: "style",
+    description: "Prefer lexicon property types over local interfaces in Composite props",
+    check(context) {
+        return checkFile(context);
+    },
+};

package/dist/lint/rules/cor021-env-literal-name.js

@@ -0,0 +1,100 @@
+import * as ts from "typescript";
+/**
+ * COR021: Literal Name in a Multi-Environment Project (#1221)
+ *
+ * A project that declares two or more `environments` and binds its ownership
+ * marker to a build parameter (`ownership.env: { param: "env" }`) is built
+ * once per environment — and every physical name that does not vary with
+ * that parameter is the SAME name in every build. The collision is silent at
+ * build time and only surfaces at apply time, when the second environment's
+ * deploy walks over the first's resources.
+ *
+ * This rule warns on the declaration: a name-bearing property (`name`, or a
+ * `*Name` property like `bucketName`) whose value is a bare string literal,
+ * in a project shaped for per-environment builds. The fix is interpolation —
+ * `` `billing-${params.env}-uploads` `` — which folds to a per-environment
+ * literal because build parameters resolve before any file is imported
+ * (#1064). See the resource-naming guide's multi-environment section.
+ *
+ * Deliberately silent when:
+ * - no project config was threaded (a bare unit test, the LSP single-file path),
+ * - the project declares fewer than two environments (nothing to collide),
+ * - `ownership.env` is not param-bound — a literal `ownership.env` (or none)
+ *   means the project is not doing per-environment builds from one source
+ *   tree, so per-instance names are presumably managed another way (the
+ *   layered-config all-in-one pattern hand-names each instance),
+ * - the value is anything other than a bare string literal — a template
+ *   interpolating `params.<name>` is the fixed shape, and other non-literal
+ *   values are EVL territory, not this rule's.
+ */
+/** Does this property name carry a physical resource name — `name` or a camelCase `*Name`? */
+function isNameBearingProperty(propName) {
+    return propName === "name" || /^[a-z][A-Za-z0-9]*Name$/.test(propName);
+}
+/** The property's declared name, for Identifier and string-literal keys; undefined for computed keys. */
+function propertyName(prop) {
+    if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))
+        return prop.name.text;
+    return undefined;
+}
+/** Whether the rule's preconditions hold: 2+ declared environments and a param-bound ownership.env. */
+function projectIsMultiEnvParamBound(config) {
+    const env = config?.ownership?.env;
+    const paramBound = typeof env === "object" && env !== null && typeof env.param === "string";
+    if (!paramBound)
+        return undefined;
+    if ((config?.environments?.length ?? 0) < 2)
+        return undefined;
+    return env.param;
+}
+/** Walk an object literal (nested included, e.g. k8s `metadata: { name }`), flagging literal name-bearing values. */
+function checkObjectLiteral(obj, paramName, context, diagnostics) {
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = propertyName(prop);
+        const value = prop.initializer;
+        if (name !== undefined &&
+            isNameBearingProperty(name) &&
+            (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value))) {
+            const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(value.getStart(context.sourceFile));
+            diagnostics.push({
+                file: context.filePath,
+                line: line + 1,
+                column: character + 1,
+                ruleId: "COR021",
+                severity: "warning",
+                message: `Literal ${name}: "${value.text}" in a multi-environment project — every environment's build ` +
+                    `produces this same physical name, so two deployed environments collide. Interpolate the env ` +
+                    `parameter: \`${value.text}-\${params.${paramName}}\` (see the resource-naming guide's ` +
+                    `multi-environment section).`,
+            });
+        }
+        if (ts.isObjectLiteralExpression(value)) {
+            checkObjectLiteral(value, paramName, context, diagnostics);
+        }
+    }
+}
+function checkNode(node, paramName, context, diagnostics) {
+    if (ts.isNewExpression(node) && node.arguments && node.arguments.length > 0) {
+        const firstArg = node.arguments[0];
+        if (ts.isObjectLiteralExpression(firstArg)) {
+            checkObjectLiteral(firstArg, paramName, context, diagnostics);
+        }
+    }
+    ts.forEachChild(node, (child) => checkNode(child, paramName, context, diagnostics));
+}
+export const cor021EnvLiteralNameRule = {
+    id: "COR021",
+    severity: "warning",
+    category: "correctness",
+    description: "In a multi-environment project with a param-bound ownership.env, name-bearing properties should interpolate the env parameter, not hold a bare literal",
+    check(context) {
+        const paramName = projectIsMultiEnvParamBound(context.projectConfig);
+        if (paramName === undefined)
+            return [];
+        const diagnostics = [];
+        checkNode(context.sourceFile, paramName, context, diagnostics);
+        return diagnostics;
+    },
+};

package/dist/lint/rules/cor022-receipt-leaf.js

@@ -0,0 +1,118 @@
+import * as ts from "typescript";
+/**
+ * COR022: Effect Receipt Is a Leaf (#1833, epic #1703)
+ *
+ * Nothing may reference an effect receipt's attributes. A receipt is the
+ * declared witness that an out-of-band effect ran — the `effect()` step
+ * (#1834) is its sole writer, on success, last (../../effect-receipt.ts).
+ * Any resource that derives a property from a receipt couples itself to a
+ * value only the effect controls: the coupling is invisible at synthesis,
+ * and the receipt's late write (or its absence after a crash) would ripple
+ * into resources that were supposed to be independent of whether the effect
+ * has fired yet.
+ *
+ * The rule walks the file's reference graph the way COR011 does: it collects
+ * every variable initialized from an `EffectReceipt(...)` call (aliases
+ * included — `const alias = receipt` is still the receipt), then flags every
+ * property or element access rooted at one of them. Const indirection fires:
+ *
+ *   const r = EffectReceipt("seeded", { effect: "db-seed", flavor: "existence" });
+ *   other.prop = r.something;   // COR022
+ *
+ * Referencing the receipt VALUE (passing `r` itself around) is not flagged —
+ * the leaf constraint is about attributes, and lexicon materialization rows
+ * legitimately take the whole declaration.
+ *
+ * Core recognizes the factory call by name; a lexicon-materialized receipt
+ * row (#1835) is recognized at build time by its marker instead — this rule
+ * is the source-level half.
+ */
+/** Simple callee name of a call: `EffectReceipt(...)` or `chant.EffectReceipt(...)`. */
+function calleeName(expr) {
+    if (ts.isIdentifier(expr.expression))
+        return expr.expression.text;
+    if (ts.isPropertyAccessExpression(expr.expression))
+        return expr.expression.name.text;
+    return undefined;
+}
+/** A variable declaration's `EffectReceipt(...)` initializer, if that is what it is. */
+export function receiptFactoryCall(decl) {
+    if (!decl.initializer || !ts.isCallExpression(decl.initializer))
+        return undefined;
+    return calleeName(decl.initializer) === "EffectReceipt" ? decl.initializer : undefined;
+}
+/**
+ * Every variable name bound to an effect receipt in this file: direct
+ * `EffectReceipt(...)` initializers plus identifier aliases, resolved to a
+ * fixpoint so declaration order does not matter. Scope-naive by design, the
+ * same trade COR011 makes — a chant source file is flat declarations.
+ */
+export function collectReceiptVariables(sourceFile) {
+    const receipts = new Set();
+    const aliases = [];
+    function visit(node) {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            if (receiptFactoryCall(node)) {
+                receipts.add(node.name.text);
+            }
+            else if (ts.isIdentifier(node.initializer)) {
+                aliases.push([node.name.text, node.initializer.text]);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const [name, source] of aliases) {
+            if (receipts.has(source) && !receipts.has(name)) {
+                receipts.add(name);
+                grew = true;
+            }
+        }
+    }
+    return receipts;
+}
+/** The accessed attribute's name, for the message: `r.something` → "something". */
+function accessedAttribute(node) {
+    if (ts.isPropertyAccessExpression(node))
+        return node.name.text;
+    const arg = node.argumentExpression;
+    return ts.isStringLiteralLike(arg) ? arg.text : "<computed>";
+}
+export const cor022ReceiptLeafRule = {
+    id: "COR022",
+    severity: "error",
+    category: "correctness",
+    description: "An effect receipt is a leaf — nothing may reference its attributes; the effect() step is the receipt's sole writer",
+    check(context) {
+        const receipts = collectReceiptVariables(context.sourceFile);
+        if (receipts.size === 0)
+            return [];
+        const diagnostics = [];
+        function visit(node) {
+            if ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
+                ts.isIdentifier(node.expression) &&
+                receipts.has(node.expression.text)) {
+                const receipt = node.expression.text;
+                const attribute = accessedAttribute(node);
+                const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(node.getStart(context.sourceFile));
+                diagnostics.push({
+                    file: context.filePath,
+                    line: line + 1,
+                    column: character + 1,
+                    ruleId: "COR022",
+                    severity: "error",
+                    message: `"${receipt}" is an effect receipt — a receipt is a leaf, and nothing may reference its ` +
+                        `attributes ("${attribute}" here). The effect() step is the receipt's sole writer, so a ` +
+                        `property derived from it couples this resource to a value only the effect controls. ` +
+                        `Reference the effect's inputs (or the resources they come from) directly instead.`,
+                });
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(context.sourceFile);
+        return diagnostics;
+    },
+};