@bleedingdev/modern-js-code-tools 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm-node/strict-effect-runtime.js

@@ -0,0 +1,325 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { SourceSyntaxError, parseSource, traverseSource, unwrapExpression } from "./source-analysis.js";
+import * as __rspack_external__babel_types_6e8337dd from "@babel/types";
+const edge = '@modern-js/bff-effect/effect-edge';
+const nodeRuntime = '@modern-js/bff-effect/effect';
+const assembly = '@modern-js/bff-effect/assembly';
+const failure = 'Generated API entries must export defineEffectBff(...) or the native Effect BFF assembly helper with an explicitly composed handler Layer and an unshadowed executable root; entries must implement handlers through HttpApiBuilder.group.';
+const MAX_API_SOURCE_MODULES = 256;
+function createEffectApiImportResolver(filename) {
+    const directory = node_fs.realpathSync(node_path.dirname(filename));
+    const owner = node_fs.realpathSync(node_path.resolve(directory, '..'));
+    const resolve = (from)=>(specifier)=>{
+            if (!specifier.startsWith('.')) return;
+            const target = node_path.resolve(node_path.dirname(from), specifier);
+            if (!target.startsWith(`${owner}${node_path.sep}`)) return;
+            for (const candidate of [
+                target,
+                `${target}.ts`,
+                `${target}.mts`
+            ])try {
+                const real = node_fs.realpathSync(candidate);
+                if (!real.startsWith(`${owner}${node_path.sep}`) || node_fs.statSync(real).size > 1000000) return;
+                return {
+                    id: real,
+                    source: node_fs.readFileSync(real, 'utf8'),
+                    resolveImport: resolve(real)
+                };
+            } catch  {}
+        };
+    return resolve(node_path.join(directory, node_path.basename(filename)));
+}
+function strictEffectRuntimeTopologyViolation(source, resolveImport) {
+    const modules = new Map();
+    const owners = new Map();
+    const paths = new Map();
+    const mutated = new Set();
+    const load = (input)=>{
+        const existing = modules.get(input.id);
+        if (existing) return existing;
+        if (modules.size >= MAX_API_SOURCE_MODULES || input.source.length > 1000000) throw new SourceSyntaxError('API source budget exceeded');
+        const file = parseSource(input.source, input.id, 'Invalid API syntax');
+        const module = {
+            ...input,
+            file
+        };
+        modules.set(input.id, module);
+        traverseSource(file, {
+            enter (nodePath) {
+                paths.set(nodePath.node, nodePath);
+                owners.set(nodePath.node, module);
+                if (nodePath.isAssignmentExpression() || nodePath.isUpdateExpression() || nodePath.isUnaryExpression({
+                    operator: 'delete'
+                })) {
+                    let target = nodePath.isAssignmentExpression() ? nodePath.node.left : nodePath.node.argument;
+                    while(__rspack_external__babel_types_6e8337dd.isMemberExpression(target))target = target.object;
+                    if (__rspack_external__babel_types_6e8337dd.isIdentifier(target)) {
+                        const binding = nodePath.scope.getBinding(target.name);
+                        if (binding) mutated.add(binding);
+                    }
+                }
+                if (nodePath.isTSModuleDeclaration() && __rspack_external__babel_types_6e8337dd.isIdentifier(nodePath.node.id)) {
+                    const binding = nodePath.scope.getBinding(nodePath.node.id.name);
+                    if (binding) mutated.add(binding);
+                }
+            }
+        });
+        return module;
+    };
+    try {
+        const entry = load({
+            id: '/entry.ts',
+            source,
+            resolveImport
+        });
+        const unwrap = (node)=>unwrapExpression(node, true);
+        const binding = (node)=>{
+            node = unwrap(node);
+            if (!__rspack_external__babel_types_6e8337dd.isIdentifier(node)) return;
+            const nodePath = paths.get(node);
+            if (!nodePath) throw new Error('Missing API lexical scope');
+            const value = nodePath.scope.getBinding(node.name);
+            return value?.constant && !mutated.has(value) ? value : void 0;
+        };
+        const declaration = (node)=>binding(node)?.path.node;
+        const imported = (node)=>{
+            const value = binding(node);
+            const decl = value?.path.node;
+            if (!decl || !__rspack_external__babel_types_6e8337dd.isImportSpecifier(decl) && !__rspack_external__babel_types_6e8337dd.isImportNamespaceSpecifier(decl) || __rspack_external__babel_types_6e8337dd.isImportSpecifier(decl) && 'type' === decl.importKind) return;
+            const statement = value.path.parent;
+            if (!__rspack_external__babel_types_6e8337dd.isImportDeclaration(statement) || 'type' === statement.importKind) return;
+            return {
+                namespace: __rspack_external__babel_types_6e8337dd.isImportNamespaceSpecifier(decl),
+                name: __rspack_external__babel_types_6e8337dd.isImportNamespaceSpecifier(decl) ? '*' : __rspack_external__babel_types_6e8337dd.isIdentifier(decl.imported) ? decl.imported.name : decl.imported.value,
+                specifier: statement.source.value
+            };
+        };
+        const namespaceSources = {
+            HttpApi: [
+                edge,
+                'effect/unstable/httpapi'
+            ],
+            HttpApiBuilder: [
+                edge,
+                'effect/unstable/httpapi'
+            ],
+            HttpRouter: [
+                edge,
+                'effect/unstable/http'
+            ]
+        };
+        const native = (node, name, sources)=>{
+            const value = imported(node);
+            if (!value) return false;
+            const importedNameMatches = value.namespace ? value.specifier === `effect/${name}` : value.name === name && value.specifier !== `effect/${name}`;
+            return importedNameMatches && (sources ?? namespaceSources[name] ?? [
+                edge
+            ]).includes(value.specifier);
+        };
+        const method = (node, namespace, member, sources)=>{
+            node = unwrap(node);
+            return __rspack_external__babel_types_6e8337dd.isMemberExpression(node) && !node.computed && __rspack_external__babel_types_6e8337dd.isIdentifier(node.property, {
+                name: member
+            }) && native(node.object, namespace, sources);
+        };
+        const initialized = (node)=>{
+            const value = binding(node);
+            return value?.kind === 'const' && __rspack_external__babel_types_6e8337dd.isVariableDeclarator(value.path.node) ? value.path.node.init ?? void 0 : void 0;
+        };
+        const moduleFor = (node)=>{
+            const value = imported(node);
+            if (!value) return;
+            const input = owners.get(node)?.resolveImport?.(value.specifier);
+            return input ? {
+                module: load(input),
+                name: value.name
+            } : void 0;
+        };
+        const exported = (module, name)=>{
+            for (const statement of module.file.program.body)if (__rspack_external__babel_types_6e8337dd.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+                if (__rspack_external__babel_types_6e8337dd.isVariableDeclaration(statement.declaration)) {
+                    for (const decl of statement.declaration.declarations)if (__rspack_external__babel_types_6e8337dd.isIdentifier(decl.id, {
+                        name
+                    })) return decl.id;
+                }
+                if (!statement.source) {
+                    const specifier = statement.specifiers.find((element)=>__rspack_external__babel_types_6e8337dd.isExportSpecifier(element) && 'type' !== element.exportKind && (__rspack_external__babel_types_6e8337dd.isIdentifier(element.exported) ? element.exported.name : element.exported.value) === name);
+                    if (__rspack_external__babel_types_6e8337dd.isExportSpecifier(specifier)) return specifier.local;
+                }
+            }
+        };
+        const externalValue = (node)=>{
+            const value = moduleFor(node);
+            return value ? exported(value.module, value.name) : void 0;
+        };
+        const apiIdentity = (node, seen = new Set())=>{
+            node = unwrap(node);
+            if (seen.has(node)) return;
+            seen.add(node);
+            const value = imported(node);
+            if (value) {
+                if (!value.specifier.startsWith('.')) return;
+                const module = moduleFor(node);
+                const exportedValue = module && exported(module.module, module.name);
+                if (exportedValue) return apiIdentity(exportedValue, seen);
+                if (module && /(?:^|\/)shared\/(?:api|rpc)\.ts$/u.test(value.specifier)) return `${module.module.id}:import:${value.name}`;
+                if (!owners.get(node)?.resolveImport && /(?:^|\/)shared\/(?:api|rpc)\.ts$/u.test(value.specifier)) return `${value.specifier}:${value.name}`;
+                return;
+            }
+            const init = initialized(node);
+            if (init && __rspack_external__babel_types_6e8337dd.isIdentifier(unwrap(init))) return apiIdentity(init, seen);
+            const valueBinding = binding(node);
+            return valueBinding ? `${owners.get(valueBinding.path.node)?.id}:${valueBinding.identifier.start}` : void 0;
+        };
+        const properties = (node)=>{
+            node = unwrap(node);
+            if (!__rspack_external__babel_types_6e8337dd.isObjectExpression(node)) return;
+            const result = new Map();
+            for (const prop of node.properties){
+                if (!__rspack_external__babel_types_6e8337dd.isObjectProperty(prop) || prop.computed || !__rspack_external__babel_types_6e8337dd.isIdentifier(prop.key) || result.has(prop.key.name)) return;
+                result.set(prop.key.name, prop.value);
+            }
+            return result;
+        };
+        const active = new Set();
+        const guarded = (node, check)=>{
+            node = unwrap(node);
+            if (active.has(node) || active.size > 128) return false;
+            active.add(node);
+            try {
+                return check(node);
+            } finally{
+                active.delete(node);
+            }
+        };
+        const layerSources = [
+            edge,
+            'effect',
+            'effect/Layer'
+        ];
+        const returned = (body)=>{
+            if (!__rspack_external__babel_types_6e8337dd.isBlockStatement(body)) return body;
+            const statements = body.body;
+            const last = statements.at(-1);
+            return statements.slice(0, -1).every((statement)=>__rspack_external__babel_types_6e8337dd.isVariableDeclaration(statement) || __rspack_external__babel_types_6e8337dd.isTSTypeAliasDeclaration(statement) || __rspack_external__babel_types_6e8337dd.isTSInterfaceDeclaration(statement)) && __rspack_external__babel_types_6e8337dd.isReturnStatement(last) ? last.argument : void 0;
+        };
+        const pipe = (node, check)=>__rspack_external__babel_types_6e8337dd.isMemberExpression(node.callee) && !node.callee.computed && __rspack_external__babel_types_6e8337dd.isIdentifier(node.callee.property, {
+                name: 'pipe'
+            }) && check(node.callee.object) && node.arguments.every((argument)=>method(argument, 'Layer', 'orDie', layerSources) || __rspack_external__babel_types_6e8337dd.isCallExpression(argument) && method(argument.callee, 'Layer', 'provide', layerSources) && argument.arguments.length > 0);
+        const handled = (node)=>{
+            node = unwrap(node);
+            if (!__rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(node) && !__rspack_external__babel_types_6e8337dd.isFunctionExpression(node)) return false;
+            const parameter = node.params[0];
+            if (!__rspack_external__babel_types_6e8337dd.isIdentifier(parameter)) return false;
+            const body = returned(node.body);
+            const chain = (value, count = 0)=>{
+                value = unwrap(value);
+                if (__rspack_external__babel_types_6e8337dd.isIdentifier(value)) return count > 0 && declaration(value) === parameter;
+                return __rspack_external__babel_types_6e8337dd.isCallExpression(value) && __rspack_external__babel_types_6e8337dd.isMemberExpression(value.callee) && !value.callee.computed && __rspack_external__babel_types_6e8337dd.isIdentifier(value.callee.property) && [
+                    'handle',
+                    'handleRaw'
+                ].includes(value.callee.property.name) && 2 === value.arguments.length && chain(value.callee.object, count + 1);
+            };
+            return !!body && chain(body);
+        };
+        const handlers = (node, api)=>guarded(node, (node)=>{
+                const init = initialized(node) ?? externalValue(node);
+                if (init) return handlers(init, api);
+                if (!__rspack_external__babel_types_6e8337dd.isCallExpression(node)) return false;
+                if (pipe(node, (value)=>handlers(value, api))) return true;
+                if (method(node.callee, 'Layer', 'mergeAll', layerSources)) return node.arguments.length > 0 && node.arguments.every((argument)=>handlers(argument, api));
+                return method(node.callee, 'HttpApiBuilder', 'group') && 3 === node.arguments.length && apiIdentity(node.arguments[0]) === api && handled(node.arguments[2]);
+            });
+        const transport = (node)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return transport(init);
+                if (!__rspack_external__babel_types_6e8337dd.isCallExpression(node)) return method(node, 'Layer', 'empty', layerSources);
+                return pipe(node, transport) || method(node.callee, 'HttpRouter', 'cors') || method(node.callee, 'Layer', 'mergeAll', layerSources) && node.arguments.length > 0 && node.arguments.every(transport);
+            });
+        const directLayer = (node, api)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return directLayer(init, api);
+                if (!__rspack_external__babel_types_6e8337dd.isCallExpression(node) || !__rspack_external__babel_types_6e8337dd.isMemberExpression(node.callee) || node.callee.computed || !__rspack_external__babel_types_6e8337dd.isIdentifier(node.callee.property, {
+                    name: 'pipe'
+                })) return false;
+                const base = unwrap(node.callee.object);
+                return __rspack_external__babel_types_6e8337dd.isCallExpression(base) && method(base.callee, 'HttpApiBuilder', 'layer') && 1 === base.arguments.length && apiIdentity(base.arguments[0]) === api && node.arguments.length > 0 && node.arguments.every((argument)=>__rspack_external__babel_types_6e8337dd.isCallExpression(argument) && method(argument.callee, 'Layer', 'provide', layerSources) && 1 === argument.arguments.length && handlers(argument.arguments[0], api));
+            });
+        const rpc = (values)=>{
+            const api = values.get('api');
+            const apiLayer = values.get('layer');
+            const apiInit = api && (initialized(api) ?? unwrap(api));
+            if (!apiInit || !__rspack_external__babel_types_6e8337dd.isCallExpression(apiInit) || !method(apiInit.callee, 'HttpApi', 'make') || 1 !== apiInit.arguments.length || !apiLayer || !transport(apiLayer)) return false;
+            const config = values.get('rpc');
+            const fields = config && properties(config);
+            const route = fields?.get('path');
+            const serialization = fields?.get('serialization');
+            if (!__rspack_external__babel_types_6e8337dd.isStringLiteral(route, {
+                value: '/rpc'
+            }) || !__rspack_external__babel_types_6e8337dd.isStringLiteral(serialization, {
+                value: 'json'
+            })) return false;
+            const group = fields?.get('group');
+            const layer = fields?.get('layer');
+            const value = group && imported(group);
+            if (!group || !layer || value?.specifier !== '../shared/rpc.ts') return false;
+            const groupValue = externalValue(group);
+            const groupInit = groupValue && initialized(groupValue);
+            if (!groupInit || !__rspack_external__babel_types_6e8337dd.isCallExpression(groupInit) || !method(groupInit.callee, 'RpcGroup', 'make', [
+                'effect/unstable/rpc',
+                '@modern-js/bff-effect/effect-client'
+            ])) return false;
+            const layerInit = initialized(layer) ?? unwrap(layer);
+            if (!__rspack_external__babel_types_6e8337dd.isCallExpression(layerInit) || !__rspack_external__babel_types_6e8337dd.isMemberExpression(layerInit.callee) || layerInit.callee.computed || !__rspack_external__babel_types_6e8337dd.isIdentifier(layerInit.callee.property, {
+                name: 'toLayer'
+            }) || apiIdentity(layerInit.callee.object) !== apiIdentity(group) || 1 !== layerInit.arguments.length) return false;
+            const implementation = unwrap(layerInit.arguments[0]);
+            if (!__rspack_external__babel_types_6e8337dd.isCallExpression(implementation) || !__rspack_external__babel_types_6e8337dd.isMemberExpression(implementation.callee) || implementation.callee.computed || !__rspack_external__babel_types_6e8337dd.isIdentifier(implementation.callee.property, {
+                name: 'of'
+            }) || apiIdentity(implementation.callee.object) !== apiIdentity(group) || 1 !== implementation.arguments.length) return false;
+            const entries = properties(implementation.arguments[0]);
+            return !!entries?.size && [
+                ...entries.values()
+            ].every((value)=>__rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(value) || __rspack_external__babel_types_6e8337dd.isFunctionExpression(value));
+        };
+        const runtime = (node)=>guarded(node, (node)=>{
+                const init = initialized(node);
+                if (init) return runtime(init);
+                if (!__rspack_external__babel_types_6e8337dd.isCallExpression(node)) return false;
+                const value = imported(node.callee);
+                if (value?.name === 'defineEffectBff' && [
+                    edge,
+                    nodeRuntime
+                ].includes(value.specifier) || value?.name === 'assembleEffectBffRuntime' && value.specifier === assembly) {
+                    if (1 !== node.arguments.length) return false;
+                    const values = properties(node.arguments[0]);
+                    if (!values) return false;
+                    if ('defineEffectBff' === value.name && values.has('rpc')) return rpc(values);
+                    const api = values.get('api');
+                    const apiBinding = api && imported(api);
+                    if (!api || apiBinding?.specifier !== '../shared/api.ts') return false;
+                    const identity = apiIdentity(api);
+                    if (!identity) return false;
+                    const layer = values.get('defineEffectBff' === value.name ? 'layer' : 'handlers');
+                    const extra = values.get('transport');
+                    return void 0 !== layer && ('defineEffectBff' === value.name ? directLayer(layer, identity) : handlers(layer, identity)) && (!extra || transport(extra));
+                }
+                const decl = declaration(node.callee);
+                const factory = decl && __rspack_external__babel_types_6e8337dd.isFunctionDeclaration(decl) ? decl : initialized(node.callee);
+                if (!factory || !__rspack_external__babel_types_6e8337dd.isFunctionDeclaration(factory) && !__rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(factory) && !__rspack_external__babel_types_6e8337dd.isFunctionExpression(factory) || !factory.body) return false;
+                const result = returned(factory.body);
+                return !!result && runtime(result);
+            });
+        const root = entry.file.program.body.find((statement)=>__rspack_external__babel_types_6e8337dd.isExportDefaultDeclaration(statement));
+        return root && runtime(root.declaration) ? void 0 : failure;
+    } catch (cause) {
+        if (cause instanceof SourceSyntaxError) return failure;
+        const message = 'object' == typeof cause && null !== cause && 'message' in cause && 'string' == typeof cause.message ? cause.message : String(cause);
+        throw new Error(`Strict Effect API analysis failed: ${message}`, {
+            cause
+        });
+    }
+}
+export { createEffectApiImportResolver, strictEffectRuntimeTopologyViolation };

package/dist/types/cli/microvertical-api-check.d.ts

@@ -0,0 +1 @@
+export declare function runMicroVerticalApiCheckCli(args?: string[], filesOnly?: boolean): Promise<number>;

package/dist/types/cli/workspace-source-check.d.ts

@@ -17,4 +17,4 @@ export type WorkspaceSourceCheckOptions = {
     readonly pluralCategories?: Readonly<Record<string, readonly string[]>>;
 };
 export declare const runWorkspaceSourceCheck: ({ cwd, sourceRoots, locales, pluralCategories, }?: WorkspaceSourceCheckOptions) => number;
-export declare const main: () => void;
+export declare const runWorkspaceSourceCheckCli: (args?: readonly string[]) => number;

package/dist/types/microvertical-api-baseline.d.ts

@@ -0,0 +1,23 @@
+export interface MicroVerticalApiBaselineExpectation {
+    /** Optional override for operation IDs outside reachable endpoint naming conventions. */
+    readonly operationPaths?: Readonly<Record<string, string>>;
+    readonly additionalPaths: Readonly<Record<string, string>>;
+    readonly apiPrefix: string;
+    readonly basePath: string;
+    readonly effectClientPackage: string;
+    readonly ownerId: string;
+    readonly readinessPath: string;
+    readonly baselinePackage: '@modern-js/bff-effect/microvertical-api';
+    readonly baselinePackageDirectory: string;
+}
+export interface MicroVerticalTopologyEntry {
+    readonly api?: {
+        readonly readiness?: {
+            readonly endpoint?: string;
+        };
+    };
+    readonly id: string;
+    readonly path?: string;
+}
+export declare const configuredMicroVerticalApiStem: (verticalPath: string, verticals: readonly MicroVerticalTopologyEntry[]) => string | undefined;
+export declare const microVerticalApiBaselineViolation: (stem: string, filePath: string, expectation: MicroVerticalApiBaselineExpectation) => string | undefined;

package/dist/types/microvertical-api-boundary.d.ts

@@ -0,0 +1,46 @@
+import { type ModuleGraph } from './module-graph.js';
+export type { MicroVerticalApiBaselineExpectation, MicroVerticalTopologyEntry, } from './microvertical-api-baseline.js';
+export { configuredMicroVerticalApiStem, microVerticalApiBaselineViolation, } from './microvertical-api-baseline.js';
+export type { ModuleGraph, ModuleGraphHop, ResolvedBinding, SourceModule, } from './module-graph.js';
+export { createModuleGraph } from './module-graph.js';
+export interface MicroVerticalConfiguredApp {
+    readonly path: string;
+    readonly id?: string;
+    readonly kind?: string;
+    readonly package?: string;
+    readonly surfaceProfile?: string;
+    readonly deliveryUnitKind?: string;
+    readonly api?: {
+        readonly stem?: string;
+        readonly prefix?: string;
+        readonly protocol?: 'rest' | 'rpc';
+        readonly operationPaths?: Readonly<Record<string, string>>;
+        readonly additionalPaths?: Readonly<Record<string, string>>;
+    };
+}
+export interface MicroVerticalApiContractRuleContext {
+    /** Workspace-relative app directory. */
+    readonly appPath: string;
+    readonly protocol: 'rest' | 'rpc';
+    /** Graph rooted at the app's shared contract (`graph.root`). */
+    readonly graph: ModuleGraph;
+}
+/** A consumer-owned contract rule; each returned message is a violation. */
+export type MicroVerticalApiContractRule = (context: MicroVerticalApiContractRuleContext) => readonly string[];
+export interface MicroVerticalApiCheckOptions {
+    readonly workspaceRoot: string;
+    readonly configuredApps?: readonly MicroVerticalConfiguredApp[];
+    /** Explicit expected installed owner, useful for isolated/non-hoisted installations. */
+    readonly baselinePackageDirectory?: string;
+    /** Rules run once per API app against its shared contract's module graph. */
+    readonly contractRules?: readonly MicroVerticalApiContractRule[];
+}
+export interface MicroVerticalApiCheckResult {
+    readonly diagnostics: readonly string[];
+    readonly toolErrors: readonly string[];
+    readonly topologyFilesAnalyzed: number;
+}
+/** Full standalone check: source runtime topology is analyzed once per entry. */
+export declare const checkMicroVerticalApiBoundaries: (options: MicroVerticalApiCheckOptions) => MicroVerticalApiCheckResult;
+/** Consumer files/export/owner checks; caller must separately run runtime topology analysis. */
+export declare const checkMicroVerticalApiConsumerFiles: (options: MicroVerticalApiCheckOptions) => MicroVerticalApiCheckResult;

package/dist/types/microvertical-api-owner.d.ts

@@ -0,0 +1,6 @@
+import type { MicroVerticalApiBaselineExpectation } from './microvertical-api-baseline.js';
+export declare const baselinePackage = "@modern-js/bff-effect/microvertical-api";
+/** Locate the installed package from this consumer's resolver, never this tool's installation. */
+export declare function resolveBaselinePackageDirectory(fromFile: string): string;
+/** Follow only public bindings and local barrels. Never examine schema implementation expressions. */
+export declare function baselinePublicIdentityIsExact(fromFile: string, expectation: MicroVerticalApiBaselineExpectation): boolean;

package/dist/types/module-graph.d.ts

@@ -0,0 +1,52 @@
+import * as t from '@babel/types';
+/** A parsed consumer module and the package directory it may traverse privately. */
+export interface SourceModule {
+    readonly file: t.File;
+    /** Real absolute path. */
+    readonly path: string;
+    /** Real package directory; relative imports may not leave it. */
+    readonly boundary: string;
+}
+/** One `name` looked up in the module at `path`, in traversal order. */
+export interface ModuleGraphHop {
+    readonly path: string;
+    readonly name: string;
+}
+/**
+ * Where a binding ends up. `declaration` is a workspace `const` initializer;
+ * `external` is a named import or re-export from a package outside the
+ * workspace source graph. `chain` starts at the requesting module and ends at
+ * the declaring module (or the last workspace module before the package).
+ */
+export type ResolvedBinding = {
+    readonly kind: 'declaration';
+    readonly expression: t.Expression;
+    readonly module: SourceModule;
+    readonly chain: readonly ModuleGraphHop[];
+} | {
+    readonly kind: 'external';
+    readonly specifier: string;
+    readonly name: string;
+    readonly chain: readonly ModuleGraphHop[];
+};
+export interface ModuleGraph {
+    readonly root: SourceModule;
+    /**
+     * Follow a local binding (`scope: 'local'`) or an export (`'export'`) of
+     * `module` through relative imports, re-exports and public workspace
+     * package exports. Unresolvable, cyclic or over-budget bindings return
+     * undefined so callers fail closed.
+     */
+    resolve(module: SourceModule, name: string, scope: 'export' | 'local'): ResolvedBinding | undefined;
+}
+/** Resolution follows `const` bindings, so a module that mutates them is unreadable. */
+export declare function parseConsumer(filePath: string): t.File;
+export declare const propertyName: (node: t.Node | undefined) => string | undefined;
+export declare const localConst: (sourceFile: t.File, name: string) => t.VariableDeclarator | undefined;
+export declare const exportedConst: (sourceFile: t.File, name: string) => t.VariableDeclarator | undefined;
+/**
+ * The module graph rooted at `filePath`. Each module is parsed once per graph;
+ * an unreadable module stays unresolved instead of assumed valid. Throws
+ * `SourceSyntaxError` when the root itself is not a readable consumer module.
+ */
+export declare function createModuleGraph(filePath: string): ModuleGraph;

package/dist/types/source-analysis.d.ts

@@ -0,0 +1,10 @@
+import { type Visitor } from '@babel/traverse';
+import * as t from '@babel/types';
+/** Only JSX extensions enable JSX: generic arrows in .ts must remain valid. */
+export declare const consumerParserPlugins: (filePath: string) => ('typescript' | 'jsx')[];
+/** Only parser/binder diagnostics are policy violations; tool failures escape. */
+export declare class SourceSyntaxError extends Error {
+}
+export declare function parseSource(source: string, filename: string, syntaxMessage?: string): t.File;
+export declare function traverseSource(file: t.File, visitor: Visitor): void;
+export declare function unwrapExpression(node: t.Node, includeAssertions?: boolean): t.Node;

package/dist/types/strict-effect-runtime.d.ts

@@ -0,0 +1,10 @@
+/** A bounded, owner-local source resolver; never executes application modules. */
+export interface EffectApiSource {
+    readonly id: string;
+    readonly source: string;
+    readonly resolveImport?: (specifier: string) => EffectApiSource | undefined;
+}
+export type EffectApiImportResolver = (specifier: string) => EffectApiSource | undefined;
+export declare function createEffectApiImportResolver(filename: string): EffectApiImportResolver;
+/** Proves binding identity and an exported composition, not the occurrence of names. */
+export declare function strictEffectRuntimeTopologyViolation(source: string, resolveImport?: EffectApiImportResolver): string | undefined;

package/package.json

@@ -23,7 +23,7 @@
   "engines": {
     "node": ">=20"
   },
-  "version": "3.9.0-ultramodern.2",
+  "version": "3.9.0-ultramodern.21",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/esm-node/index.js",
   "typesVersions": {
@@ -33,6 +33,9 @@
       ],
       "oxlint-plugin": [
         "./dist/types/oxlint-plugin.d.ts"
+      ],
+      "microvertical-api-boundary": [
+        "./dist/types/microvertical-api-boundary.d.ts"
       ]
     }
   },
@@ -45,6 +48,11 @@
       },
       "default": "./dist/esm-node/index.js"
     },
+    "./strict-effect-runtime": {
+      "types": "./dist/types/strict-effect-runtime.d.ts",
+      "import": "./dist/esm-node/strict-effect-runtime.js",
+      "require": "./dist/cjs/strict-effect-runtime.cjs"
+    },
     "./oxlint-plugin": {
       "types": "./dist/types/oxlint-plugin.d.ts",
       "node": {
@@ -52,18 +60,28 @@
         "require": "./dist/cjs/oxlint-plugin.cjs"
       },
       "default": "./dist/esm-node/oxlint-plugin.js"
+    },
+    "./microvertical-api-boundary": {
+      "types": "./dist/types/microvertical-api-boundary.d.ts",
+      "import": "./dist/esm-node/microvertical-api-boundary.js",
+      "require": "./dist/cjs/microvertical-api-boundary.cjs"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "dependencies": {
-    "oxlint": "1.81.0"
+    "@babel/parser": "^8.0.6",
+    "@babel/traverse": "^8.0.6",
+    "@babel/types": "^8.0.6",
+    "oxlint": "1.85.0",
+    "resolve.exports": "2.0.3"
   },
   "devDependencies": {
-    "@rslib/core": "1.0.0",
+    "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.6.2",
     "@typescript/native-preview": "7.0.0-dev.20260707.2"
   },
   "sideEffects": false,
@@ -71,9 +89,14 @@
     "access": "public"
   },
   "modern:source": "./src/index.ts",
+  "bin": {
+    "modern-api-check": "bin/modern-api-check.mjs",
+    "modern-api-check-files": "bin/modern-api-check-files.mjs",
+    "modern-i18n-check": "bin/modern-i18n-check.mjs"
+  },
   "scripts": {
     "build": "rm -rf dist && rslib build -c rslib.config.mts",
     "dev": "rslib build -c rslib.config.mts -w",
-    "test": "rstest --passWithNoTests"
+    "test": "rstest"
   }
 }