@starci/hfs 4.11.21 → 4.12.0

package/runtime/scripts/hfs/architecture/context-owner.mjs

@@ -1,6 +1,5 @@
 import { contextModelOf, connectionsComposedBy } from './context-map.mjs';
 import { machineKit } from './machine-ast.mjs';
-
 /**
  * R174 `context-owner` (BE_CONTEXT_OWNER). A connection of hfs.json IS a bounded context, and its `owner` is the one service app that composes it:
  *   - an api or worker app passes to the database module registration (or lists in its options) only the connections it owns (a monolith's one
@@ -14,77 +13,90 @@ import { machineKit } from './machine-ast.mjs';
  * name pattern. A runner app with a registration whose connection name cannot be resolved is not judged for missing connections.
  */
 export const CONTEXT_OWNER_RULE_IDS = ['BE_CONTEXT_OWNER'];
-
 const RULE = 'BE_CONTEXT_OWNER';
 const SERVICE_KINDS = new Set(['api', 'worker']);
 const RUNNER_KINDS = new Set(['migrate', 'cli']);
-
 // What each app composes: [{connection, file, node}] from the database module registration and from the registration literals under its files.
 const compositionsOf = (kit, resolver, model, appOf) => {
-  const composed = new Map(resolver.repo.apps.map(app => [app.name, { items: [], unresolved: false }]));
-  for (const app of resolver.repo.apps) {
-    for (const item of connectionsComposedBy(kit, app.name).items) composed.get(app.name).items.push(item);
-  }
-  for (const site of model.registrations) {
-    const app = appOf(site.file.rel);
-    if (!app || !composed.has(app)) continue;
-    if (site.connection === null) composed.get(app).unresolved = true;
-    else composed.get(app).items.push({ connection: site.connection, file: site.file, node: site.node });
-  }
-  return composed;
+    const apps = resolver.repo.apps;
+    const composed = new Map(apps.map((app) => [app.name, { items: [], unresolved: false }]));
+    for (const app of apps) {
+        const entry = composed.get(app.name);
+        if (!entry)
+            continue;
+        for (const item of connectionsComposedBy(kit, app.name).items)
+            entry.items.push(item);
+    }
+    for (const site of model.registrations) {
+        const app = appOf(site.file.rel);
+        const entry = app ? composed.get(app) : undefined;
+        if (!app || !entry)
+            continue;
+        if (site.connection === null)
+            entry.unresolved = true;
+        else
+            entry.items.push({ connection: site.connection, file: site.file, node: site.node });
+    }
+    return composed;
 };
-
 // A service app composes only the connections it owns; a runner app composes every declared connection with tables.
 const judgeComposition = (app, { items, unresolved }, { owners, model, kit, once }) => {
-  if (SERVICE_KINDS.has(app.kind)) {
-    for (const { connection, file, node } of items) {
-      const owner = owners.get(connection);
-      if (owner && owner !== app.name) {
-        once(`${app.name}|${connection}`, { ...kit.at(file.rel, file.sourceFile, node), message: `App ${app.name} composes connection ${connection}, the context owned by app ${owner}; an app composes only the contexts it owns. Reach that context through the API or the events of ${owner}.`, connection, app: app.name, owner });
-      }
+    if (SERVICE_KINDS.has(app.kind)) {
+        for (const { connection, file, node } of items) {
+            const owner = owners.get(connection);
+            if (owner && owner !== app.name) {
+                once(`${app.name}|${connection}`, { ...kit.at(file.rel, file.sourceFile, node), message: `App ${app.name} composes connection ${connection}, the context owned by app ${owner}; an app composes only the contexts it owns. Reach that context through the API or the events of ${owner}.`, connection, app: app.name, owner });
+            }
+        }
     }
-  } else if (RUNNER_KINDS.has(app.kind) && !unresolved) {
-    const root = kit.appRoot(app.name);
-    const present = new Set(items.map(item => item.connection));
-    const held = new Set([...model.registered.values()].flatMap(entry => [...entry.connections.keys()]));
-    for (const connection of owners.keys()) {
-      if (!root || present.has(connection) || !held.has(connection) || !items.length) continue;
-      once(`${app.name}|missing|${connection}`, { ...kit.at(root.rel, root.sourceFile, root.sourceFile), message: `The ${app.kind} app ${app.name} does not compose connection ${connection}; migrations run only through it, once per connection, so it registers every declared connection that holds tables.`, connection, app: app.name });
+    else if (RUNNER_KINDS.has(app.kind) && !unresolved) {
+        const root = kit.appRoot(app.name);
+        const present = new Set(items.map(item => item.connection));
+        const held = new Set([...model.registered.values()].flatMap(entry => [...entry.connections.keys()]));
+        for (const connection of owners.keys()) {
+            if (!root || present.has(connection) || !held.has(connection) || !items.length)
+                continue;
+            once(`${app.name}|missing|${connection}`, { ...kit.at(root.rel, root.sourceFile, root.sourceFile), message: `The ${app.kind} app ${app.name} does not compose connection ${connection}; migrations run only through it, once per connection, so it registers every declared connection that holds tables.`, connection, app: app.name });
+        }
     }
-  }
-  return items.length;
+    return items.length;
 };
-
 export function checkContextOwner(input) {
-  const { graph } = input;
-  const kit = machineKit(input);
-  const { resolver } = kit;
-  const model = contextModelOf(kit, graph);
-  const violations = [];
-  const owners = new Map(resolver.repo.connections.map(connection => [connection.name, connection.owner]));
-  let compositions = 0;
-  let imports = 0;
-  const seen = new Set();
-  const once = (key, violation) => { if (!seen.has(key)) { seen.add(key); violations.push({ ruleId: RULE, ...violation }); } };
-  const appOf = rel => { const classified = resolver.classifyPath(rel); return classified.slot?.startsWith('be.app.') ? classified.bindings?.app ?? null : null; };
-
-  const composed = compositionsOf(kit, resolver, model, appOf);
-
-  for (const app of resolver.repo.apps) {
-    compositions += judgeComposition(app, composed.get(app.name), { owners, model, kit, once });
-  }
-
-  const kinds = new Map(resolver.repo.apps.map(app => [app.name, app.kind]));
-  for (const edge of graph.edges) {
-    const app = appOf(edge.from);
-    if (!app || !SERVICE_KINDS.has(kinds.get(app))) continue;
-    const context = model.contextOfFile(edge.to);
-    if (!context) continue;
-    imports += 1;
-    const owner = owners.get(context);
-    if (owner && owner !== app) {
-      once(`${edge.from}|${edge.to}`, { path: edge.from, line: edge.line, column: edge.column, message: `App ${app} imports ${graph.files.get(edge.to).owner.root}, a capability of context ${context} owned by app ${owner}; an app composes only the contexts it owns, so use the API or the events of ${owner} instead.`, connection: context, app, owner });
+    const { graph } = input;
+    const kit = machineKit(input);
+    const { resolver } = kit;
+    const model = contextModelOf(kit, graph);
+    const violations = [];
+    const connections = resolver.repo.connections;
+    const apps = resolver.repo.apps;
+    const owners = new Map(connections.map((connection) => [connection.name, connection.owner]));
+    let compositions = 0;
+    let imports = 0;
+    const seen = new Set();
+    const once = (key, violation) => { if (!seen.has(key)) {
+        seen.add(key);
+        violations.push({ ruleId: RULE, ...violation });
+    } };
+    const appOf = (rel) => { const classified = resolver.classifyPath(rel); return classified.slot?.startsWith('be.app.') ? classified.bindings?.app ?? null : null; };
+    const composed = compositionsOf(kit, resolver, model, appOf);
+    for (const app of apps) {
+        const composition = composed.get(app.name);
+        if (composition)
+            compositions += judgeComposition(app, composition, { owners, model, kit, once });
+    }
+    const kinds = new Map(apps.map((app) => [app.name, app.kind]));
+    for (const edge of graph.edges) {
+        const app = appOf(edge.from);
+        if (!app || !SERVICE_KINDS.has(kinds.get(app) ?? ''))
+            continue;
+        const context = model.contextOfFile(edge.to);
+        if (!context)
+            continue;
+        imports += 1;
+        const owner = owners.get(context);
+        if (owner && owner !== app) {
+            once(`${edge.from}|${edge.to}`, { path: edge.from, line: edge.line, column: edge.column, message: `App ${app} imports ${graph.files.get(edge.to)?.owner?.root}, a capability of context ${context} owned by app ${owner}; an app composes only the contexts it owns, so use the API or the events of ${owner} instead.`, connection: context, app, owner });
+        }
     }
-  }
-  return { violations, coverage: { status: 'checked', apps: resolver.repo.apps.length, compositions, contextImports: imports } };
+    return { violations, coverage: { status: 'checked', apps: apps.length, compositions, contextImports: imports } };
 }

package/runtime/scripts/hfs/architecture/context-platform-tables.d.mts

@@ -0,0 +1,18 @@
+import type { ArchitectureViolation, CheckInput } from './hfs-graph.mjs';
+/**
+ * R178 `context-platform-tables` (BE_CONTEXT_PLATFORM_TABLES). A platform capability the manifest lists as `perConnection` (the event-bus outbox,
+ * the job table) keeps its tables on EVERY connection that uses it: when a call into the capability passes the entity manager of connection C
+ * (an `Inject<C>EntityManager` property, or the manager of a transaction on one), the capability's `<c>Entities` and `<c>Migrations` must be
+ * registered on C, or the row the call writes has no table in C's database. The caller's connection is proven by the manager's origin; a call
+ * whose manager origin cannot be proven is not judged.
+ */
+export declare const CONTEXT_PLATFORM_TABLES_RULE_IDS: string[];
+export declare function checkContextPlatformTables(input: CheckInput): {
+    violations: ArchitectureViolation[];
+    coverage: {
+        calls: number;
+        unproven: number;
+        status: string;
+        perConnectionCapabilities: number;
+    };
+};

package/runtime/scripts/hfs/architecture/context-platform-tables.mjs

@@ -1,7 +1,6 @@
 import { contextModelOf } from './context-map.mjs';
 import { machineKit } from './machine-ast.mjs';
 import { byCodeUnit } from '../../lib/list.mjs';
-
 /**
  * R178 `context-platform-tables` (BE_CONTEXT_PLATFORM_TABLES). A platform capability the manifest lists as `perConnection` (the event-bus outbox,
  * the job table) keeps its tables on EVERY connection that uses it: when a call into the capability passes the entity manager of connection C
@@ -10,52 +9,57 @@ import { byCodeUnit } from '../../lib/list.mjs';
  * whose manager origin cannot be proven is not judged.
  */
 export const CONTEXT_PLATFORM_TABLES_RULE_IDS = ['BE_CONTEXT_PLATFORM_TABLES'];
-
 const RULE = 'BE_CONTEXT_PLATFORM_TABLES';
-
 function perConnectionHome(kit, model, checker, file, node) {
-  const { ts } = kit;
-  const callee = ts.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
-  const home = kit.declarationsOf(checker, callee).map(kit.ownerOfDeclaration).find(Boolean);
-  if (!home || !model.perConnection.has(home.root) || file.owner?.root === home.root) return undefined;
-  return home;
+    const { ts } = kit;
+    const callee = ts.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
+    const home = kit.declarationsOf(checker, callee).map(kit.ownerOfDeclaration).find(Boolean);
+    if (!home || !model.perConnection.has(home.root) || file.owner?.root === home.root)
+        return undefined;
+    return home;
 }
-
 function unregisteredViolations(kit, model, scope, home, connections, seen) {
-  const { file, node } = scope;
-  const registeredOn = model.registered.get(home.root)?.connections ?? new Map();
-  const violations = [];
-  for (const connection of connections) {
-    if (registeredOn.has(connection)) continue;
-    const key = `${file.rel}|${node.getStart()}|${connection}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    violations.push({ ruleId: RULE, ...kit.at(file.rel, file.sourceFile, node), message: `${file.rel} passes the entity manager of connection ${connection} to ${home.name}, but the tables of ${home.name} are not registered on ${connection} (registered: ${[...registeredOn.keys()].sort(byCodeUnit).join(', ') || 'none'}); register its entities and migrations on ${connection} too, so the table exists in the database of that context.`, connection, capability: home.name });
-  }
-  return violations;
+    const { file, node } = scope;
+    const registeredOn = model.registered.get(home.root)?.connections ?? new Map();
+    const violations = [];
+    for (const connection of connections) {
+        if (registeredOn.has(connection))
+            continue;
+        const key = `${file.rel}|${node.getStart()}|${connection}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        violations.push({ ruleId: RULE, ...kit.at(file.rel, file.sourceFile, node), message: `${file.rel} passes the entity manager of connection ${connection} to ${home.name}, but the tables of ${home.name} are not registered on ${connection} (registered: ${[...registeredOn.keys()].sort(byCodeUnit).join(', ') || 'none'}); register its entities and migrations on ${connection} too, so the table exists in the database of that context.`, connection, capability: home.name });
+    }
+    return violations;
 }
-
 export function checkContextPlatformTables(input) {
-  const { graph } = input;
-  const kit = machineKit(input);
-  const { ts } = kit;
-  const model = contextModelOf(kit, graph);
-  const violations = [];
-  const counts = { calls: 0, unproven: 0 };
-  if (!model.perConnection.size) return { violations, coverage: { status: 'checked', perConnectionCapabilities: 0, ...counts } };
-  const seen = new Set();
-  for (const file of graph.files.values()) {
-    const checker = kit.checkerOf(file.sourceFile);
-    kit.walk(file.sourceFile, node => {
-      if (!ts.isCallExpression(node)) return true;
-      const home = perConnectionHome(kit, model, checker, file, node);
-      if (!home) return true;
-      counts.calls += 1;
-      const connections = new Set(node.arguments.map(argument => model.connectionOfManager(checker, argument)).filter(Boolean));
-      if (!connections.size) { counts.unproven += 1; return true; }
-      violations.push(...unregisteredViolations(kit, model, { file, node }, home, connections, seen));
-      return true;
-    });
-  }
-  return { violations, coverage: { status: 'checked', perConnectionCapabilities: model.perConnection.size, ...counts } };
+    const { graph } = input;
+    const kit = machineKit(input);
+    const { ts } = kit;
+    const model = contextModelOf(kit, graph);
+    const violations = [];
+    const counts = { calls: 0, unproven: 0 };
+    if (!model.perConnection.size)
+        return { violations, coverage: { status: 'checked', perConnectionCapabilities: 0, ...counts } };
+    const seen = new Set();
+    for (const file of graph.files.values()) {
+        const checker = kit.checkerOf(file.sourceFile);
+        kit.walk(file.sourceFile, (node) => {
+            if (!ts.isCallExpression(node))
+                return true;
+            const home = perConnectionHome(kit, model, checker, file, node);
+            if (!home)
+                return true;
+            counts.calls += 1;
+            const connections = new Set(node.arguments.map(argument => model.connectionOfManager(checker, argument)).filter((connection) => Boolean(connection)));
+            if (!connections.size) {
+                counts.unproven += 1;
+                return true;
+            }
+            violations.push(...unregisteredViolations(kit, model, { file, node }, home, connections, seen));
+            return true;
+        });
+    }
+    return { violations, coverage: { status: 'checked', perConnectionCapabilities: model.perConnection.size, ...counts } };
 }

package/runtime/scripts/hfs/architecture/context-transaction.d.mts

@@ -0,0 +1,20 @@
+import type { MachineInput } from './machine-ast.mjs';
+import type { Violation } from './ast-walks.mjs';
+export interface ContextTransactionResult {
+    violations: Violation[];
+    coverage: {
+        status: 'checked';
+        transactions: number;
+        unproven: number;
+    };
+}
+/**
+ * R176 `context-transaction` (BE_CONTEXT_TRANSACTION). One transaction touches one context's connection. In the callback of
+ * `<manager>.transaction(async (manager) => ...)`, where `<manager>` is proven to be the entity manager of connection C (an
+ * `Inject<C>EntityManager` property or parameter), the code never:
+ *   - uses the entity manager of another declared connection (proven by its injector's home file); or
+ *   - calls a method of a domain or projection capability of another context (that capability writes through its own connection).
+ * Work that spans contexts is a saga of one transaction per context, linked by events. A receiver whose connection cannot be proven is not judged.
+ */
+export declare const CONTEXT_TRANSACTION_RULE_IDS: string[];
+export declare function checkContextTransaction(input: MachineInput): ContextTransactionResult;

package/runtime/scripts/hfs/architecture/context-transaction.mjs

@@ -1,6 +1,5 @@
 import { contextModelOf } from './context-map.mjs';
 import { machineKit } from './machine-ast.mjs';
-
 /**
  * R176 `context-transaction` (BE_CONTEXT_TRANSACTION). One transaction touches one context's connection. In the callback of
  * `<manager>.transaction(async (manager) => ...)`, where `<manager>` is proven to be the entity manager of connection C (an
@@ -10,64 +9,67 @@ import { machineKit } from './machine-ast.mjs';
  * Work that spans contexts is a saga of one transaction per context, linked by events. A receiver whose connection cannot be proven is not judged.
  */
 export const CONTEXT_TRANSACTION_RULE_IDS = ['BE_CONTEXT_TRANSACTION'];
-
 const RULE = 'BE_CONTEXT_TRANSACTION';
-
 const SPAN_ADVICE = "one transaction touches one context's connection. Span contexts with a saga: one transaction per context, linked by events.";
-
 /** Reports an entity manager of another connection, or a call into another context's capability, found inside a transaction callback. */
 function inspectInner(scope, file, checker, connection, inner) {
-  const { ts, kit, model, graph, report } = scope;
-  if (ts.isPropertyAccessExpression(inner)) {
-    const other = model.connectionOfManager(checker, inner);
-    if (other && other !== connection) report(file, inner, `A transaction on connection ${connection} uses the entity manager of connection ${other}; ${SPAN_ADVICE}`, { connection, other });
-  }
-  if (!ts.isCallExpression(inner)) return;
-  const callee = ts.isPropertyAccessExpression(inner.expression) ? inner.expression.name : inner.expression;
-  const declaration = kit.declarationsOf(checker, callee)[0];
-  const rel = declaration ? kit.graphPath(declaration) : null;
-  const context = rel ? model.contextOfFile(rel) : null;
-  if (context && context !== connection) {
-    report(file, inner, `A transaction on connection ${connection} calls ${graph.files.get(rel).owner.root} of context ${context}; ${SPAN_ADVICE}`, { connection, other: context });
-  }
+    const { ts, kit, model, graph, report } = scope;
+    if (ts.isPropertyAccessExpression(inner)) {
+        const other = model.connectionOfManager(checker, inner);
+        if (other && other !== connection)
+            report(file, inner, `A transaction on connection ${connection} uses the entity manager of connection ${other}; ${SPAN_ADVICE}`, { connection, other });
+    }
+    if (!ts.isCallExpression(inner))
+        return;
+    const callee = ts.isPropertyAccessExpression(inner.expression) ? inner.expression.name : inner.expression;
+    const declaration = kit.declarationsOf(checker, callee)[0];
+    const rel = declaration ? kit.graphPath(declaration) : null;
+    const context = rel ? model.contextOfFile(rel) : null;
+    if (rel && context && context !== connection) {
+        report(file, inner, `A transaction on connection ${connection} calls ${graph.files.get(rel)?.owner?.root} of context ${context}; ${SPAN_ADVICE}`, { connection, other: context });
+    }
 }
-
 /** Judges a `.transaction(...)` call: counts it as proven or unproven and inspects its callback body; any other node is skipped. */
 function inspectTransaction(scope, file, checker, node) {
-  const { ts, kit, model, counts } = scope;
-  if (!(ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'transaction')) return;
-  const callback = node.arguments.find(argument => ts.isArrowFunction(argument) || ts.isFunctionExpression(argument));
-  if (!callback) return;
-  const connection = model.connectionOfManager(checker, node.expression.expression);
-  if (!connection) { counts.unproven += 1; return; }
-  counts.transactions += 1;
-  kit.walk(callback.body, inner => {
-    inspectInner(scope, file, checker, connection, inner);
-    return true;
-  });
+    const { ts, kit, model, counts } = scope;
+    if (!(ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'transaction'))
+        return;
+    const callback = node.arguments.find(argument => ts.isArrowFunction(argument) || ts.isFunctionExpression(argument));
+    if (!callback)
+        return;
+    const connection = model.connectionOfManager(checker, node.expression.expression);
+    if (!connection) {
+        counts.unproven += 1;
+        return;
+    }
+    counts.transactions += 1;
+    kit.walk(callback.body, inner => {
+        inspectInner(scope, file, checker, connection, inner);
+        return true;
+    });
 }
-
 export function checkContextTransaction(input) {
-  const { graph } = input;
-  const kit = machineKit(input);
-  const { ts } = kit;
-  const model = contextModelOf(kit, graph);
-  const violations = [];
-  const counts = { transactions: 0, unproven: 0 };
-  const seen = new Set();
-  const report = (file, node, message, extra) => {
-    const key = `${file.rel}|${node.getStart()}|${message}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    violations.push({ ruleId: RULE, ...kit.at(file.rel, file.sourceFile, node), message, ...extra });
-  };
-  const scope = { ts, kit, model, graph, report, counts };
-  for (const file of graph.files.values()) {
-    const checker = kit.checkerOf(file.sourceFile);
-    kit.walk(file.sourceFile, node => {
-      inspectTransaction(scope, file, checker, node);
-      return true;
-    });
-  }
-  return { violations, coverage: { status: 'checked', transactions: counts.transactions, unproven: counts.unproven } };
+    const { graph } = input;
+    const kit = machineKit(input);
+    const { ts } = kit;
+    const model = contextModelOf(kit, graph);
+    const violations = [];
+    const counts = { transactions: 0, unproven: 0 };
+    const seen = new Set();
+    const report = (file, node, message, extra) => {
+        const key = `${file.rel}|${node.getStart()}|${message}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        violations.push({ ruleId: RULE, ...kit.at(file.rel, file.sourceFile, node), message, ...extra });
+    };
+    const scope = { ts, kit, model, graph, report, counts };
+    for (const file of graph.files.values()) {
+        const checker = kit.checkerOf(file.sourceFile);
+        kit.walk(file.sourceFile, node => {
+            inspectTransaction(scope, file, checker, node);
+            return true;
+        });
+    }
+    return { violations, coverage: { status: 'checked', transactions: counts.transactions, unproven: counts.unproven } };
 }

package/runtime/scripts/hfs/architecture/contract-fixture-guard.d.mts

@@ -0,0 +1,37 @@
+import type { Resolver } from '../slots.mjs';
+import type { Violation } from './ast-walks.mjs';
+import type { ArchitectureConfig, TypeScriptApi } from './config.mjs';
+export interface ContractFixtureGuardResult {
+    violations: Violation[];
+    coverage: {
+        status: 'checked';
+        fixtureFakes: number;
+        contractSpecs: number;
+    };
+}
+/**
+ * R47 `contract-fixture-guard` (BE_CONTRACT_UNGUARDED). A fake at the network edge serves payload fixtures; a fixture drifts
+ * from the real provider silently unless a sandbox contract spec compares them. So every `fakes/<provider>/` of the test
+ * world that holds payload fixtures (`payloads/*.json`) needs at least one `src/tests/contract/<provider>/*.contract-spec.ts`
+ * (slot be.tests.contract) that, in its AST,
+ *   1. references that provider's fixtures: a call whose argument is the provider's name as a string literal (the world's
+ *      fixture accessor, `renderPayload("<provider>", ...)`), an import from `fakes/<provider>/`, or a string that names
+ *      `fakes/<provider>/`; and
+ *   2. compares shapes: an `expect(<... shapeOf(real) ...>).toEqual(<... shapeOf(fixture) ...>)` (or `toStrictEqual`), where
+ *      `shapeOf` is the helper the world vocabulary names (knowledge/hfs/slots.yaml ruleParams.be.contractShape.helper) and
+ *      is imported, never declared in the spec.
+ * A fake with fixtures and no such spec is a finding at its first fixture. The tree is the tracked one over the world's own
+ * slot; nothing names a path. Fakes the test-world library provides (declared in `test-world.config.ts`, held in the library
+ * package) have no tracked fixtures here and are guarded by the library's own contract specs, so only the repository's own
+ * `fakes/<provider>/` folders are judged.
+ */
+export declare const CONTRACT_FIXTURE_GUARD_RULE_IDS: string[];
+export declare function checkContractFixtureGuard(input: {
+    config: ArchitectureConfig;
+    graph: {
+        resolver: Resolver;
+    };
+    context: {
+        ts: TypeScriptApi;
+    };
+}): ContractFixtureGuardResult;