@bleedingdev/modern-js-code-tools 3.9.0-ultramodern.1 → 3.9.0-ultramodern.10

package/dist/cjs/microvertical-api-baseline.cjs

@@ -0,0 +1,677 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    configuredMicroVerticalApiStem: ()=>configuredMicroVerticalApiStem,
+    consumerParserPlugins: ()=>consumerParserPlugins,
+    microVerticalApiBaselineViolation: ()=>microVerticalApiBaselineViolation
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const parser_namespaceObject = require("@babel/parser");
+const traverse_namespaceObject = require("@babel/traverse");
+var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
+const types_namespaceObject = require("@babel/types");
+const external_microvertical_api_owner_cjs_namespaceObject = require("./microvertical-api-owner.cjs");
+const consumerParserPlugins = (filePath)=>filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ? [
+        "typescript",
+        'jsx'
+    ] : [
+        "typescript"
+    ];
+class ConsumerSyntaxError extends Error {
+}
+class ConsumerValidationHub extends traverse_namespaceObject.Hub {
+    buildError(_node, message) {
+        return new ConsumerSyntaxError(message);
+    }
+}
+function parseConsumer(filePath) {
+    if (external_node_fs_default().statSync(filePath).size > 1000000) throw new Error(`${filePath}: consumer source exceeds 1 MB analysis budget`);
+    let file;
+    try {
+        file = (0, parser_namespaceObject.parse)(external_node_fs_default().readFileSync(filePath, 'utf8'), {
+            sourceType: 'module',
+            sourceFilename: filePath,
+            plugins: consumerParserPlugins(filePath)
+        });
+    } catch (error) {
+        if ('object' == typeof error && null !== error && 'code' in error && 'BABEL_PARSER_SYNTAX_ERROR' === error.code) throw new ConsumerSyntaxError(error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+    const program = traverse_namespaceObject.NodePath.get({
+        hub: new ConsumerValidationHub(),
+        parentPath: void 0,
+        parent: file,
+        container: file,
+        key: 'program'
+    });
+    program.setContext();
+    traverse_default()(file, {
+        AssignmentExpression (p) {
+            throw new ConsumerSyntaxError(`contract bindings must be immutable at ${p.node.start}`);
+        },
+        UpdateExpression (p) {
+            throw new ConsumerSyntaxError(`contract bindings must be immutable at ${p.node.start}`);
+        },
+        TSModuleDeclaration () {
+            throw new ConsumerSyntaxError('contract bindings must not be merged with namespaces');
+        }
+    }, program.scope, void 0, program);
+    return file;
+}
+const camelCaseStem = (stem)=>stem.replaceAll(/-([a-z0-9])/gu, (_match, letter)=>letter.toUpperCase());
+const pascalCaseStem = (stem)=>{
+    const camelStem = camelCaseStem(stem);
+    return `${camelStem.slice(0, 1).toUpperCase()}${camelStem.slice(1)}`;
+};
+const identifierName = (node)=>void 0 !== node && types_namespaceObject.isIdentifier(node) ? node.name : void 0;
+const propertyName = (node)=>{
+    if (void 0 !== node && (types_namespaceObject.isIdentifier(node) || types_namespaceObject.isStringLiteral(node) || types_namespaceObject.isNumericLiteral(node))) return types_namespaceObject.isIdentifier(node) ? node.name : String(node.value);
+};
+const accessPath = (node)=>{
+    if (types_namespaceObject.isIdentifier(node)) return [
+        node.name
+    ];
+    if (types_namespaceObject.isMemberExpression(node) && !node.computed && types_namespaceObject.isIdentifier(node.property)) {
+        const parent = accessPath(node.object);
+        return void 0 === parent ? void 0 : [
+            ...parent,
+            node.property.name
+        ];
+    }
+};
+const isAccessPath = (node, expected)=>accessPath(node)?.join('.') === expected.join('.');
+const unwrapExpression = (expression)=>{
+    let current = expression;
+    while(types_namespaceObject.isTSAsExpression(current) || types_namespaceObject.isParenthesizedExpression(current) || types_namespaceObject.isTSSatisfiesExpression(current))current = current.expression;
+    return current;
+};
+const stringLiteral = (expression)=>{
+    if (null == expression) return;
+    const unwrapped = unwrapExpression(expression);
+    return types_namespaceObject.isStringLiteral(unwrapped) ? unwrapped.value : void 0;
+};
+const numericLiteral = (expression)=>{
+    if (null == expression) return;
+    const unwrapped = unwrapExpression(expression);
+    return types_namespaceObject.isNumericLiteral(unwrapped) ? Number(unwrapped.value) : void 0;
+};
+const callExpression = (expression, callee)=>{
+    if (null == expression) return;
+    const unwrapped = unwrapExpression(expression);
+    return types_namespaceObject.isCallExpression(unwrapped) && isAccessPath(unwrapped.callee, callee) ? unwrapped : void 0;
+};
+const localConst = (sourceFile, name)=>{
+    for (const item of sourceFile.program.body){
+        const statement = types_namespaceObject.isExportNamedDeclaration(item) ? item.declaration : item;
+        if (!types_namespaceObject.isVariableDeclaration(statement) || 'const' !== statement.kind) continue;
+        const matches = statement.declarations.filter((declaration)=>types_namespaceObject.isIdentifier(declaration.id, {
+                name
+            }));
+        if (1 === matches.length) return matches[0];
+    }
+};
+const exportedConst = (sourceFile, name)=>{
+    for (const statement of sourceFile.program.body)if (types_namespaceObject.isExportNamedDeclaration(statement) && 'type' !== statement.exportKind) {
+        if (types_namespaceObject.isVariableDeclaration(statement.declaration) && 'const' === statement.declaration.kind) {
+            const declaration = statement.declaration.declarations.find((value)=>types_namespaceObject.isIdentifier(value.id, {
+                    name
+                }));
+            if (declaration) return declaration;
+        }
+        if (!statement.source && statement.specifiers.some((value)=>types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && types_namespaceObject.isIdentifier(value.local, {
+                name
+            }) && types_namespaceObject.isIdentifier(value.exported, {
+                name
+            }))) return localConst(sourceFile, name);
+    }
+};
+const resolveRelativeModulePath = (fromPath, specifier)=>{
+    if (!/^\.\.?\//u.test(specifier)) return;
+    const resolved = external_node_path_default().resolve(external_node_path_default().dirname(fromPath), specifier);
+    const stem = resolved.replace(/\.(?:[cm]?[jt]sx?)$/u, '');
+    for (const candidate of [
+        `${stem}.ts`,
+        `${stem}.tsx`,
+        external_node_path_default().join(stem, 'index.ts'),
+        external_node_path_default().join(stem, 'index.tsx')
+    ])if (external_node_fs_default().existsSync(candidate) && external_node_fs_default().statSync(candidate).isFile()) return candidate;
+};
+const createModuleReader = (root)=>{
+    const modules = new Map([
+        [
+            root.path,
+            root
+        ]
+    ]);
+    return (filePath)=>{
+        if (modules.has(filePath)) return modules.get(filePath);
+        if (modules.size >= 256) return;
+        let module;
+        try {
+            module = {
+                file: parseConsumer(filePath),
+                path: filePath
+            };
+        } catch  {
+            module = void 0;
+        }
+        modules.set(filePath, module);
+        return module;
+    };
+};
+const importedBinding = (module, name)=>{
+    for (const statement of module.file.program.body)if (types_namespaceObject.isImportDeclaration(statement) && 'type' !== statement.importKind) {
+        for (const specifier of statement.specifiers)if (types_namespaceObject.isIdentifier(specifier.local, {
+            name
+        })) {
+            if (types_namespaceObject.isImportSpecifier(specifier) && 'type' !== specifier.importKind) return {
+                imported: propertyName(specifier.imported) ?? name,
+                specifier: statement.source.value
+            };
+            if (types_namespaceObject.isImportDefaultSpecifier(specifier)) return {
+                imported: 'default',
+                specifier: statement.source.value
+            };
+        }
+    }
+};
+const reexportedBinding = (module, name)=>{
+    for (const statement of module.file.program.body){
+        if (!types_namespaceObject.isExportNamedDeclaration(statement) || 'type' === statement.exportKind) continue;
+        const specifier = statement.specifiers.find((value)=>types_namespaceObject.isExportSpecifier(value) && 'type' !== value.exportKind && propertyName(value.exported) === name);
+        if (void 0 !== specifier && types_namespaceObject.isExportSpecifier(specifier)) return {
+            local: specifier.local.name,
+            ...statement.source ? {
+                specifier: statement.source.value
+            } : {}
+        };
+    }
+};
+const defaultExport = (module)=>{
+    for (const statement of module.file.program.body){
+        if (!types_namespaceObject.isExportDefaultDeclaration(statement)) continue;
+        const declaration = statement.declaration;
+        if (types_namespaceObject.isIdentifier(declaration)) return declaration.name;
+        return types_namespaceObject.isExpression(declaration) ? declaration : void 0;
+    }
+};
+const resolveBinding = (module, name, scope, readModule, seen)=>{
+    const key = `${scope}:${module.path}#${name}`;
+    if (seen.has(key) || seen.size >= 512) return;
+    seen.add(key);
+    const declaration = 'export' === scope ? exportedConst(module.file, name) : localConst(module.file, name);
+    if (declaration?.init) return {
+        expression: declaration.init,
+        module
+    };
+    const throughModule = (specifier, imported)=>{
+        const resolvedPath = resolveRelativeModulePath(module.path, specifier);
+        const target = void 0 === resolvedPath ? void 0 : readModule(resolvedPath);
+        return void 0 === target ? void 0 : resolveBinding(target, imported, 'export', readModule, seen);
+    };
+    if ('local' === scope) {
+        const imported = importedBinding(module, name);
+        return void 0 === imported ? void 0 : throughModule(imported.specifier, imported.imported);
+    }
+    if ('default' === name) {
+        const exported = defaultExport(module);
+        if ('string' == typeof exported) return resolveBinding(module, exported, 'local', readModule, seen);
+        return void 0 === exported ? void 0 : {
+            expression: exported,
+            module
+        };
+    }
+    const reexported = reexportedBinding(module, name);
+    if (void 0 !== reexported) return void 0 === reexported.specifier ? resolveBinding(module, reexported.local, 'local', readModule, seen) : throughModule(reexported.specifier, reexported.local);
+    for (const statement of module.file.program.body){
+        if (!types_namespaceObject.isExportAllDeclaration(statement) || 'type' === statement.exportKind) continue;
+        const resolved = throughModule(statement.source.value, name);
+        if (void 0 !== resolved) return resolved;
+    }
+};
+const objectLiteral = (expression)=>{
+    if (null == expression) return;
+    const unwrapped = unwrapExpression(expression);
+    return types_namespaceObject.isObjectExpression(unwrapped) ? unwrapped : void 0;
+};
+const propertyAssignments = (properties)=>{
+    const assignments = new Map();
+    for (const property of properties){
+        if (!types_namespaceObject.isObjectProperty(property) || property.computed || property.shorthand) return;
+        const name = propertyName(property.key);
+        if (void 0 === name || assignments.has(name)) return;
+        assignments.set(name, property);
+    }
+    return assignments;
+};
+const exactCall = (expression, callee, argumentCount)=>{
+    const call = callExpression(expression, callee);
+    return call?.arguments.length === argumentCount ? call : void 0;
+};
+const sharedSchemaObject = (declaration, sharedSchemaName, protectedFields)=>{
+    if (declaration?.init == null) return;
+    const initializer = unwrapExpression(declaration.init);
+    if (types_namespaceObject.isIdentifier(initializer) && initializer.name === sharedSchemaName) return {
+        assignments: new Map(),
+        identity: true
+    };
+    const struct = exactCall(initializer, [
+        'Schema',
+        'Struct'
+    ], 1);
+    const schemaObject = objectLiteral(struct?.arguments[0]);
+    if (void 0 === schemaObject) return;
+    const spreads = schemaObject.properties.filter(types_namespaceObject.isSpreadElement);
+    const assignments = propertyAssignments(schemaObject.properties.filter((property)=>!types_namespaceObject.isSpreadElement(property)));
+    if (1 !== spreads.length || !spreads.every((spread)=>isAccessPath(spread.argument, [
+            sharedSchemaName,
+            'fields'
+        ])) || void 0 === assignments || protectedFields.some((field)=>assignments.has(field))) return;
+    return {
+        assignments,
+        identity: false
+    };
+};
+const directCallChain = (expression)=>{
+    if (null == expression) return;
+    let current = unwrapExpression(expression);
+    const methods = [];
+    while(types_namespaceObject.isCallExpression(current) && types_namespaceObject.isMemberExpression(current.callee) && !current.callee.computed && types_namespaceObject.isIdentifier(current.callee.property) && !types_namespaceObject.isIdentifier(current.callee.object)){
+        methods.unshift({
+            arguments: current.arguments,
+            name: current.callee.property.name
+        });
+        current = unwrapExpression(current.callee.object);
+    }
+    if (!types_namespaceObject.isCallExpression(current)) return;
+    return {
+        base: current,
+        methods
+    };
+};
+const brandedStringSchemaIsExact = (declaration, brand)=>{
+    const initializer = declaration?.init;
+    if (null == initializer) return false;
+    const pipeCall = unwrapExpression(initializer);
+    if (!types_namespaceObject.isCallExpression(pipeCall) || !types_namespaceObject.isMemberExpression(pipeCall.callee) || pipeCall.callee.computed || !types_namespaceObject.isIdentifier(pipeCall.callee.property, {
+        name: 'pipe'
+    }) || !isAccessPath(pipeCall.callee.object, [
+        'Schema',
+        'String'
+    ]) || 1 !== pipeCall.arguments.length) return false;
+    const brandCall = exactCall(pipeCall.arguments[0], [
+        'Schema',
+        'brand'
+    ], 1);
+    return stringLiteral(brandCall?.arguments[0]) === brand;
+};
+const importedRuntimeNames = (statement, expectedPackage)=>{
+    if (!types_namespaceObject.isImportDeclaration(statement) || statement.source.value !== expectedPackage || 'type' === statement.importKind) return [];
+    return statement.specifiers.flatMap((value)=>types_namespaceObject.isImportSpecifier(value) && 'type' !== value.importKind && types_namespaceObject.isIdentifier(value.imported) && value.imported.name === value.local.name ? [
+            value.local.name
+        ] : []);
+};
+const importsExactBindings = (sourceFile, expectedPackage, expectedBindings)=>{
+    const names = new Set(sourceFile.program.body.flatMap((statement)=>importedRuntimeNames(statement, expectedPackage)));
+    return expectedBindings.every((name)=>names.has(name));
+};
+const baselineBindings = [
+    'MicroVerticalBuildMarkerSchema',
+    'MicroVerticalReadinessSchema',
+    'createMicroVerticalOperationContext'
+];
+const importsSharedBaselinePrimitives = (sourceFile, expectedPackage)=>importsExactBindings(sourceFile, expectedPackage, baselineBindings);
+const singleAddedArgument = (expression, factory, names)=>{
+    const chain = directCallChain(expression);
+    if (void 0 === chain || !isAccessPath(chain.base.callee, factory)) return;
+    const [method] = chain.methods;
+    if (1 !== chain.base.arguments.length || !names.includes(stringLiteral(chain.base.arguments[0]) ?? '') || 1 !== chain.methods.length || method?.name !== 'add' || 1 !== method.arguments.length) return;
+    return method.arguments[0];
+};
+const foundationIsExact = (declaration, stem, readinessSchemaName)=>{
+    const group = singleAddedArgument(declaration?.init, [
+        'HttpApi',
+        'make'
+    ], [
+        `${pascalCaseStem(stem)}FoundationApi`,
+        `${pascalCaseStem(stem)}ApiFoundation`
+    ]);
+    const endpointExpression = singleAddedArgument(group, [
+        'HttpApiGroup',
+        'make'
+    ], [
+        'foundation'
+    ]);
+    const endpoint = exactCall(endpointExpression, [
+        'HttpApiEndpoint',
+        'get'
+    ], 3);
+    const endpointOptions = objectLiteral(endpoint?.arguments[2]);
+    const endpointProperties = void 0 === endpointOptions ? void 0 : propertyAssignments(endpointOptions.properties);
+    return void 0 !== endpoint && 'readiness' === stringLiteral(endpoint.arguments[0]) && stringLiteral(endpoint.arguments[1]) === `/${stem}/readiness` && endpointProperties?.size === 1 && identifierName(endpointProperties.get('success')?.value) === readinessSchemaName;
+};
+const rootComposesFoundation = (sourceFile, declaration, stem, foundationName)=>{
+    const chain = directCallChain(declaration?.init);
+    const first = chain?.methods[0];
+    return void 0 !== chain && isAccessPath(chain.base.callee, [
+        'HttpApi',
+        'make'
+    ]) && 1 === chain.base.arguments.length && stringLiteral(chain.base.arguments[0]) === `${pascalCaseStem(stem)}Api` && chain.methods.length > 0 && chain.methods.every((method, index)=>1 === method.arguments.length && ('add' === method.name || 'addHttpApi' === method.name || index === chain.methods.length - 1 && 'pipe' === method.name && 'identity' === identifierName(method.arguments[0]) && importsExactBindings(sourceFile, 'effect', [
+            'identity'
+        ]))) && first?.name === 'addHttpApi' && identifierName(first.arguments[0]) === foundationName;
+};
+const nonEndpointCombinators = {
+    api: {
+        annotate: 2,
+        annotateMerge: 1,
+        middleware: 1
+    },
+    group: {
+        annotate: 2,
+        annotateEndpoints: 2,
+        annotateEndpointsMerge: 1,
+        annotateMerge: 1,
+        middleware: 1
+    }
+};
+const reachableEndpoints = (rootModule, declaration)=>{
+    const readModule = createModuleReader(rootModule);
+    const active = new Set();
+    const endpoints = [];
+    const identities = new Set();
+    const verbs = {
+        get: 'GET',
+        post: 'POST',
+        put: 'PUT',
+        patch: 'PATCH',
+        del: 'DELETE',
+        delete: 'DELETE',
+        head: 'HEAD',
+        options: 'OPTIONS'
+    };
+    let visits = 0;
+    const visit = (expression, module, kind, group = '')=>{
+        if (!expression) return false;
+        const node = unwrapExpression(expression);
+        if (active.has(node) || active.size >= 128 || ++visits > 2048) return false;
+        active.add(node);
+        try {
+            if (types_namespaceObject.isIdentifier(node)) {
+                const resolved = resolveBinding(module, node.name, 'local', readModule, new Set());
+                return void 0 !== resolved && visit(resolved.expression, resolved.module, kind, group);
+            }
+            if ('endpoint' === kind) {
+                if (!types_namespaceObject.isCallExpression(node) || node.arguments.length < 2 || node.arguments.length > 3) return false;
+                const callee = accessPath(node.callee);
+                const method = callee?.length === 2 && 'HttpApiEndpoint' === callee[0] ? verbs[callee[1]] : void 0;
+                const name = stringLiteral(node.arguments[0]);
+                const routePath = stringLiteral(node.arguments[1]);
+                if (!method || !name || !routePath) return false;
+                const identity = `${group}:${name}`;
+                if (identities.has(identity)) return false;
+                identities.add(identity);
+                endpoints.push({
+                    group,
+                    name,
+                    method,
+                    routePath
+                });
+                return true;
+            }
+            const chain = directCallChain(node);
+            if (!chain || !isAccessPath(chain.base.callee, [
+                'api' === kind ? 'HttpApi' : 'HttpApiGroup',
+                'make'
+            ]) || 1 !== chain.base.arguments.length) return false;
+            const name = stringLiteral(chain.base.arguments[0]);
+            if (!name) return false;
+            const chainStart = endpoints.length;
+            const combinators = nonEndpointCombinators[kind];
+            return chain.methods.every((method)=>{
+                if ('prefix' === method.name) {
+                    const prefix = stringLiteral(method.arguments[0]);
+                    if (1 !== method.arguments.length || !prefix?.startsWith('/')) return false;
+                    for(let index = chainStart; index < endpoints.length; index += 1){
+                        const endpoint = endpoints[index];
+                        endpoints[index] = {
+                            ...endpoint,
+                            routePath: `${prefix}${endpoint.routePath}`
+                        };
+                    }
+                    return true;
+                }
+                const combinatorArity = combinators[method.name];
+                if (void 0 !== combinatorArity) return method.arguments.length === combinatorArity;
+                if (1 !== method.arguments.length) return false;
+                if ('pipe' === method.name) return 'identity' === identifierName(method.arguments[0]) && importsExactBindings(module.file, 'effect', [
+                    'identity'
+                ]);
+                if ('add' === method.name) return visit(method.arguments[0], module, 'api' === kind ? 'group' : 'endpoint', 'group' === kind ? name : '');
+                return 'api' === kind && 'addHttpApi' === method.name && visit(method.arguments[0], module, 'api');
+            });
+        } finally{
+            active.delete(node);
+        }
+    };
+    return visit(declaration?.init, rootModule, 'api') ? endpoints : void 0;
+};
+const operationContextFields = (property)=>{
+    const constructorCall = exactCall(property.value, [
+        'createMicroVerticalOperationContext'
+    ], 1);
+    const input = objectLiteral(constructorCall?.arguments[0]);
+    return void 0 === input ? void 0 : propertyAssignments(input.properties);
+};
+const operationContextIdentity = (property)=>{
+    const fields = operationContextFields(property);
+    const method = stringLiteral(fields?.get('method')?.value);
+    const operationId = stringLiteral(fields?.get('operationId')?.value);
+    const routePath = stringLiteral(fields?.get('routePath')?.value);
+    if (fields?.size !== 3 || void 0 === method || void 0 === operationId || void 0 === routePath) return;
+    return {
+        method,
+        operationId,
+        routePath
+    };
+};
+const operationContextIsConstructed = (property, stem, propertyKey, operationPaths, endpoints)=>{
+    const identity = operationContextIdentity(property);
+    if (void 0 === identity) return false;
+    const { method, operationId, routePath } = identity;
+    if (!/^[A-Z]+$/u.test(method) || !/^\/(?!.*(?:^|\/)\.\.?\/)[^\s?#]*$/u.test(routePath)) return false;
+    const apiName = `${pascalCaseStem(stem)}Api`;
+    if ('readiness' === propertyKey && ('GET' !== method || routePath !== `/${stem}/readiness`)) return false;
+    return operationId === `${apiName}:${routePath}` || operationPaths[operationId] === routePath || endpoints.some((endpoint)=>endpoint.name === propertyKey && endpoint.method === method && endpoint.routePath === routePath && (operationId === `${apiName}:${endpoint.group}:${propertyKey}` || 'readiness' === propertyKey && operationId === `${apiName}:${camelCaseStem(stem)}:readiness`));
+};
+const operationMapIsConnected = (declaration, stem, operationPaths, endpoints)=>{
+    const map = objectLiteral(declaration?.init);
+    const properties = void 0 === map ? void 0 : propertyAssignments(map.properties);
+    return void 0 !== properties && properties.has('readiness') && [
+        ...properties
+    ].every(([key, property])=>operationContextIsConstructed(property, stem, key, operationPaths, endpoints));
+};
+const constAssertionObject = (declaration)=>{
+    const initializer = declaration?.init;
+    if (null == initializer || !types_namespaceObject.isTSAsExpression(initializer) || !types_namespaceObject.isTSTypeReference(initializer.typeAnnotation) || !types_namespaceObject.isIdentifier(initializer.typeAnnotation.typeName, {
+        name: 'const'
+    })) return;
+    return objectLiteral(initializer.expression);
+};
+const metadataIsExact = (declaration, expectation, endpoints)=>{
+    const object = constAssertionObject(declaration);
+    const fields = void 0 === object ? void 0 : propertyAssignments(object.properties);
+    const expectedFields = [
+        [
+            'apiPrefix',
+            expectation.apiPrefix
+        ],
+        [
+            'basePath',
+            expectation.basePath
+        ],
+        [
+            'ownerId',
+            expectation.ownerId
+        ],
+        [
+            'readinessPath',
+            expectation.readinessPath
+        ]
+    ];
+    if (!fields || !expectedFields.every(([field, value])=>stringLiteral(fields.get(field)?.value) === value)) return false;
+    const common = new Set(expectedFields.map(([field])=>field));
+    return [
+        ...fields
+    ].every(([field, property])=>{
+        if (common.has(field)) return true;
+        const value = stringLiteral(property.value);
+        if (void 0 === value) return false;
+        const explicit = expectation.additionalPaths[field];
+        if (void 0 !== explicit) return value === explicit;
+        if (!value.startsWith(`${expectation.apiPrefix}/`) || /[\s?#]/u.test(value) || value.split('/').some((segment)=>'.' === segment || '..' === segment)) return false;
+        return endpoints.some((endpoint)=>{
+            const route = `${expectation.apiPrefix}${endpoint.routePath}`;
+            return route === value || route.startsWith(`${value}/`);
+        });
+    });
+};
+const markerSchemaIsShared = (sourceFile, declaration)=>{
+    const schema = sharedSchemaObject(declaration, 'MicroVerticalBuildMarkerSchema', [
+        'build',
+        'buildMarker',
+        'deployProfile',
+        'packageName',
+        'sourceRevision',
+        'surface',
+        'version'
+    ]);
+    if (void 0 === schema || schema.identity) return schema?.identity === true;
+    const brandedField = (property, brand)=>identifierName(property.value) === `${brand}Schema` && brandedStringSchemaIsExact(localConst(sourceFile, `${brand}Schema`), brand);
+    const validators = new Map([
+        [
+            'appId',
+            (property)=>brandedField(property, 'AppId')
+        ],
+        [
+            'unitId',
+            (property)=>brandedField(property, 'UnitId')
+        ],
+        [
+            'kind',
+            (property)=>'microvertical-delivery-unit' === stringLiteral(exactCall(property.value, [
+                    'Schema',
+                    'Literal'
+                ], 1)?.arguments[0])
+        ],
+        [
+            'schemaVersion',
+            (property)=>1 === numericLiteral(exactCall(property.value, [
+                    'Schema',
+                    'Literal'
+                ], 1)?.arguments[0])
+        ]
+    ]);
+    return [
+        ...schema.assignments
+    ].every(([field, property])=>validators.get(field)?.(property) === true);
+};
+const readinessSchemaIsShared = (declaration, markerSchemaName, ownerMarkerIsIdentity)=>{
+    const schema = sharedSchemaObject(declaration, 'MicroVerticalReadinessSchema', [
+        'checks',
+        'status',
+        'versionSkew'
+    ]);
+    return void 0 !== schema && (schema.identity && ownerMarkerIsIdentity || 1 === schema.assignments.size && identifierName(schema.assignments.get('marker')?.value) === markerSchemaName);
+};
+const declarationIsIdentifier = (declaration, identifier)=>declaration?.init != null && identifierName(unwrapExpression(declaration.init)) === identifier;
+const validateParsedContract = (module, stem, expectation)=>{
+    const sourceFile = module.file;
+    const exportStem = camelCaseStem(stem);
+    const foundationName = `${exportStem}FoundationApi`;
+    const markerSchemaName = `${exportStem}MarkerSchema`;
+    const readinessSchemaName = `${exportStem}ReadinessSchema`;
+    const markerDeclaration = exportedConst(sourceFile, markerSchemaName);
+    if (!importsExactBindings(sourceFile, expectation.effectClientPackage, [
+        'HttpApi',
+        'HttpApiEndpoint',
+        'HttpApiGroup',
+        'Schema'
+    ])) return 'MicroVertical root contract must import exact Effect API primitives from the framework client package';
+    if (!importsSharedBaselinePrimitives(sourceFile, expectation.baselinePackage)) return 'MicroVertical root contract must import exact baseline primitives from the framework baseline package';
+    if (!markerSchemaIsShared(sourceFile, markerDeclaration)) return 'MicroVertical root contract must consume the shared build marker schema without overriding shared fields';
+    if (!readinessSchemaIsShared(exportedConst(sourceFile, readinessSchemaName), markerSchemaName, declarationIsIdentifier(markerDeclaration, 'MicroVerticalBuildMarkerSchema'))) return 'MicroVertical readiness schema must consume the shared readiness schema without overriding shared fields';
+    if (!foundationIsExact(exportedConst(sourceFile, foundationName), stem, readinessSchemaName)) return 'MicroVertical readiness foundation API must directly compose its exact readiness endpoint and foundation identity';
+    if (!rootComposesFoundation(sourceFile, exportedConst(sourceFile, `${exportStem}Api`), stem, foundationName)) return 'MicroVertical root API must explicitly compose its readiness foundation API';
+    const endpoints = reachableEndpoints(module, exportedConst(sourceFile, `${exportStem}Api`));
+    if (!endpoints) return 'MicroVertical root API must compose bounded native endpoint declarations without ambiguous identities';
+    if (!operationMapIsConnected(exportedConst(sourceFile, `${exportStem}OperationContexts`), stem, expectation.operationPaths ?? {}, endpoints)) return 'MicroVertical operation map must construct every operation with the shared context constructor';
+    if (!metadataIsExact(exportedConst(sourceFile, `${exportStem}ApiContract`), expectation, endpoints)) return 'MicroVertical root contract must keep exact owner and API path metadata without forbidden fields';
+};
+const configuredMicroVerticalApiStem = (verticalPath, verticals)=>{
+    const topologyVertical = verticals.find((vertical)=>(vertical.path ?? `verticals/${vertical.id}`) === verticalPath);
+    const endpoint = topologyVertical?.api?.readiness?.endpoint;
+    return endpoint?.match(/^\/([a-z0-9]+(?:-[a-z0-9]+)*)\/readiness$/u)?.[1];
+};
+const microVerticalApiBaselineViolation = (stem, filePath, expectation)=>{
+    try {
+        const sourceFile = parseConsumer(filePath);
+        if (!(0, external_microvertical_api_owner_cjs_namespaceObject.baselinePublicIdentityIsExact)(filePath, expectation)) return 'MicroVertical baseline imports must resolve the exact framework owner public export and schema identity';
+        return validateParsedContract({
+            file: sourceFile,
+            path: filePath
+        }, stem, expectation);
+    } catch (error) {
+        if (error instanceof ConsumerSyntaxError) return `MicroVertical root contract must be valid TypeScript syntax (${error.message})`;
+        throw error;
+    }
+};
+exports.configuredMicroVerticalApiStem = __webpack_exports__.configuredMicroVerticalApiStem;
+exports.consumerParserPlugins = __webpack_exports__.consumerParserPlugins;
+exports.microVerticalApiBaselineViolation = __webpack_exports__.microVerticalApiBaselineViolation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "configuredMicroVerticalApiStem",
+    "consumerParserPlugins",
+    "microVerticalApiBaselineViolation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});