@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/npm-packages.js

@@ -1,473 +1,10 @@
-/**
- * NPM Package Type Resolution
- *
- * Functions for discovering and extracting type information from npm packages
- * that have TypeScript declaration files (.d.ts).
- */
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { resolvePackageTypesPath } from './resolve-package-types.js';
-import { extractFunctionLikes } from './function-like.js';
-import { inferDataTypeFromTS } from './type-mappings.js';
-import { getSharedProject } from './shared-project.js';
-/**
- * Find all node_modules directories starting from fromDir and walking up.
- */
-function findNodeModulesDirs(fromDir) {
-    const dirs = [];
-    let current = path.resolve(fromDir);
-    const root = path.parse(current).root;
-    while (current !== root) {
-        const candidate = path.join(current, 'node_modules');
-        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-            dirs.push(candidate);
-        }
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return dirs;
-}
-/**
- * List all packages in a node_modules directory (including scoped packages).
- */
-function listPackagesInNodeModules(nmDir) {
-    const packages = [];
-    if (!fs.existsSync(nmDir))
-        return packages;
-    try {
-        const entries = fs.readdirSync(nmDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name.startsWith('@')) {
-                const scopeDir = path.join(nmDir, entry.name);
-                try {
-                    const scopedEntries = fs.readdirSync(scopeDir, { withFileTypes: true });
-                    for (const scopedEntry of scopedEntries) {
-                        if (scopedEntry.isDirectory()) {
-                            packages.push(`${entry.name}/${scopedEntry.name}`);
-                        }
-                    }
-                }
-                catch {
-                    // Ignore permission errors
-                }
-            }
-            else {
-                packages.push(entry.name);
-            }
-        }
-    }
-    catch {
-        // Ignore permission errors
-    }
-    return packages;
-}
-/**
- * Get list of all packages that have TypeScript declarations (.d.ts files).
- * Any package with types can be used as a node type in workflows.
- * Excludes @types/* packages as they are type augmentations.
- *
- * @param workdir - Directory to start searching from
- * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
- * @returns Object with packages array, each containing name and typesPath
- */
-export function getTypedPackages(workdir, nodeModulesOverride) {
-    const nodeModulesDirs = nodeModulesOverride
-        ? [nodeModulesOverride]
-        : findNodeModulesDirs(workdir);
-    const typed = [];
-    const seenPackages = new Set();
-    for (const nmDir of nodeModulesDirs) {
-        const packages = listPackagesInNodeModules(nmDir);
-        for (const pkg of packages) {
-            if (pkg.startsWith('@types/'))
-                continue;
-            if (seenPackages.has(pkg))
-                continue;
-            seenPackages.add(pkg);
-            const typesPath = resolvePackageTypesPath(pkg, workdir, nodeModulesOverride);
-            if (typesPath) {
-                typed.push({ name: pkg, typesPath });
-            }
-        }
-    }
-    return { packages: typed };
-}
-const PRIMITIVE_TYPES = new Set(['string', 'number', 'boolean', 'any', 'unknown', 'never']);
-function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
- * Infer node type from a function declaration in a .d.ts file.
- */
-function inferNodeTypeFromDtsFunction(fn, packageName) {
-    const fnName = fn.getName();
-    if (!fnName)
-        return null;
-    const ports = [];
-    // Add execute input port (mandatory)
-    ports.push({
-        name: 'execute',
-        defaultLabel: 'Execute',
-        reference: 'execute',
-        type: 'STEP',
-        direction: 'INPUT',
-        defaultOrder: 0,
-    });
-    // Infer inputs from parameters
-    for (const param of fn.getParameters()) {
-        const paramName = param.getName();
-        const tsType = param.getType().getText(param);
-        const dataType = inferDataTypeFromTS(tsType);
-        ports.push({
-            name: paramName,
-            defaultLabel: capitalize(paramName),
-            reference: paramName,
-            type: dataType,
-            direction: 'INPUT',
-        });
-    }
-    // Infer outputs from return type
-    let returnType = fn.getReturnType();
-    const returnTypeText = returnType.getText();
-    let isAsync = false;
-    // Unwrap Promise<T>
-    if (returnTypeText.startsWith('Promise<')) {
-        isAsync = true;
-        const typeArgs = returnType.getTypeArguments();
-        if (typeArgs && typeArgs.length > 0) {
-            returnType = typeArgs[0];
-        }
-    }
-    const unwrappedText = returnType.getText();
-    if (unwrappedText !== 'void' && unwrappedText !== 'undefined' && unwrappedText !== 'never') {
-        const isPrimitive = PRIMITIVE_TYPES.has(unwrappedText);
-        const isArray = unwrappedText.endsWith('[]') || unwrappedText.startsWith('Array<');
-        const properties = returnType.getProperties();
-        const isObjectLike = !isPrimitive && !isArray && returnType.isObject() && properties.length > 0;
-        const dataProps = isObjectLike
-            ? properties.filter(p => p.getName() !== 'onSuccess' && p.getName() !== 'onFailure')
-            : [];
-        let dataOutputOrder = 2; // after onSuccess(0) and onFailure(1)
-        if (isObjectLike && dataProps.length <= 8) {
-            for (const prop of dataProps) {
-                const propName = prop.getName();
-                const propType = prop.getTypeAtLocation(fn.getTypeResolutionNode());
-                ports.push({
-                    name: propName,
-                    defaultLabel: capitalize(propName),
-                    reference: propName,
-                    type: inferDataTypeFromTS(propType.getText()),
-                    direction: 'OUTPUT',
-                    defaultOrder: dataOutputOrder++,
-                });
-            }
-        }
-        else {
-            // Single result output port
-            const dataType = inferDataTypeFromTS(unwrappedText);
-            ports.push({
-                name: 'result',
-                defaultLabel: 'Result',
-                reference: 'result',
-                type: dataType,
-                direction: 'OUTPUT',
-                defaultOrder: dataOutputOrder++,
-            });
-        }
-    }
-    // Add mandatory control flow output ports (before data outputs)
-    ports.push({
-        name: 'onSuccess',
-        defaultLabel: 'On Success',
-        reference: 'onSuccess',
-        type: 'STEP',
-        direction: 'OUTPUT',
-        defaultOrder: 0,
-    });
-    ports.push({
-        name: 'onFailure',
-        defaultLabel: 'On Failure',
-        reference: 'onFailure',
-        type: 'STEP',
-        direction: 'OUTPUT',
-        defaultOrder: 1,
-        failure: true,
-    });
-    return {
-        name: fnName,
-        variant: 'FUNCTION',
-        category: 'NPM Packages',
-        function: fnName,
-        label: fnName,
-        importSource: packageName,
-        ports,
-        synchronicity: isAsync ? 'ASYNC' : 'SYNC',
-        description: `${fnName} from ${packageName}`,
-    };
-}
-/**
- * Get callable exports from a package's .d.ts file and return as TNodeType[].
- *
- * Uses ts-morph's symbol-based export enumeration to handle all export
- * patterns: declare function, declare const with function types,
- * re-exports from submodules, star exports, etc.
- *
- * @param packageName - The npm package name
- * @param workdir - Directory to start searching from
- * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
- * @returns Array of node types for the package's callable exports
- */
-export function getPackageExports(packageName, workdir, nodeModulesOverride) {
-    const typesPath = resolvePackageTypesPath(packageName, workdir, nodeModulesOverride);
-    if (!typesPath) {
-        return [];
-    }
-    try {
-        const project = getSharedProject();
-        const dtsContent = fs.readFileSync(typesPath, 'utf-8');
-        // Add the .d.ts file and nearby declaration files to the project so
-        // ts-morph can resolve re-exports (including `export * from './submodule'`).
-        const pkgDir = path.dirname(typesPath);
-        const addedFiles = [];
-        try {
-            const globPattern = path.join(pkgDir, '**/*.d.{ts,cts,mts}');
-            for (const file of project.addSourceFilesAtPaths(globPattern)) {
-                addedFiles.push(file.getFilePath());
-            }
-        }
-        catch {
-            // Glob may fail on some filesystems; fall back to single file
-        }
-        let dtsFile = project.getSourceFile(typesPath);
-        if (!dtsFile) {
-            dtsFile = project.addSourceFileAtPath(typesPath);
-        }
-        const nodeTypes = [];
-        const seenFunctionNames = new Set();
-        // First pass: try symbol-based enumeration (handles re-exports, declare const, etc.)
-        // Maximum data output ports before collapsing to a single "result" port
-        const MAX_DATA_OUTPUT_PORTS = 8;
-        const fileSymbol = dtsFile.getSymbol();
-        if (fileSymbol) {
-            for (const exportSymbol of fileSymbol.getExports()) {
-                let exportName = exportSymbol.getName();
-                if (seenFunctionNames.has(exportName))
-                    continue;
-                // Check if this export is callable (has call signatures)
-                const exportType = exportSymbol.getTypeAtLocation(dtsFile);
-                const callSignatures = exportType.getCallSignatures();
-                if (callSignatures.length === 0)
-                    continue;
-                // Handle export= (CJS): skip namespaces, include single functions
-                if (exportName === 'export=') {
-                    // If the type has many non-call properties, it's a namespace (lodash)
-                    const props = exportType.getProperties().filter(p => !p.getName().startsWith('__'));
-                    if (props.length > 5)
-                        continue; // Namespace with many methods — skip
-                    // Try to get the real name from the declaration
-                    const decl = exportSymbol.getValueDeclaration();
-                    const declName = decl && 'getName' in decl ? decl.getName?.() : undefined;
-                    if (declName && declName !== 'export=') {
-                        exportName = declName;
-                    }
-                    else {
-                        // Try aliased declarations
-                        const aliased = exportSymbol.getAliasedSymbol?.();
-                        const aliasedName = aliased?.getName();
-                        if (aliasedName && aliasedName !== 'export=' && aliasedName !== '__type') {
-                            exportName = aliasedName;
-                        }
-                        else {
-                            continue; // Can't determine a useful name — skip
-                        }
-                    }
-                }
-                // Handle default exports: resolve to the actual function name
-                if (exportName === 'default') {
-                    const decl = exportSymbol.getValueDeclaration();
-                    const declName = decl && 'getName' in decl ? decl.getName?.() : undefined;
-                    if (declName && declName !== 'default') {
-                        exportName = declName;
-                    }
-                    else {
-                        const aliased = exportSymbol.getAliasedSymbol?.();
-                        const aliasedName = aliased?.getName();
-                        if (aliasedName && aliasedName !== 'default' && aliasedName !== '__type') {
-                            exportName = aliasedName;
-                        }
-                        // If still "default", keep it — some packages genuinely have unnamed default exports
-                    }
-                }
-                if (seenFunctionNames.has(exportName))
-                    continue;
-                seenFunctionNames.add(exportName);
-                // Use the first call signature to infer ports
-                const sig = callSignatures[0];
-                const ports = [];
-                // Execute input port
-                ports.push({
-                    name: 'execute', defaultLabel: 'Execute', reference: 'execute',
-                    type: 'STEP', direction: 'INPUT', defaultOrder: 0,
-                });
-                // Input ports from parameters
-                let inputOrder = 1;
-                for (const param of sig.getParameters()) {
-                    const paramName = param.getName();
-                    const paramType = param.getTypeAtLocation(dtsFile);
-                    const dataType = inferDataTypeFromTS(paramType.getText());
-                    ports.push({
-                        name: paramName, defaultLabel: capitalize(paramName), reference: paramName,
-                        type: dataType, direction: 'INPUT', defaultOrder: inputOrder++,
-                    });
-                }
-                // Output ports from return type
-                let returnType = sig.getReturnType();
-                const returnText = returnType.getText();
-                let isAsync = false;
-                if (returnText.startsWith('Promise<')) {
-                    isAsync = true;
-                    const typeArgs = returnType.getTypeArguments();
-                    if (typeArgs.length > 0)
-                        returnType = typeArgs[0];
-                }
-                // Step output ports first (control flow), then data outputs
-                ports.push({
-                    name: 'onSuccess', defaultLabel: 'On Success', reference: 'onSuccess',
-                    type: 'STEP', direction: 'OUTPUT', defaultOrder: 0,
-                });
-                ports.push({
-                    name: 'onFailure', defaultLabel: 'On Failure', reference: 'onFailure',
-                    type: 'STEP', direction: 'OUTPUT', defaultOrder: 1, failure: true,
-                });
-                let outputOrder = 2;
-                const unwrapped = returnType.getText();
-                if (unwrapped !== 'void' && unwrapped !== 'undefined' && unwrapped !== 'never') {
-                    const isPrimitive = PRIMITIVE_TYPES.has(unwrapped);
-                    const isArray = unwrapped.endsWith('[]') || unwrapped.startsWith('Array<');
-                    const properties = returnType.getProperties();
-                    const isObjectLike = !isPrimitive && !isArray && returnType.isObject() && properties.length > 0;
-                    const dataProps = isObjectLike
-                        ? properties.filter(p => p.getName() !== 'onSuccess' && p.getName() !== 'onFailure')
-                        : [];
-                    if (isObjectLike && dataProps.length <= MAX_DATA_OUTPUT_PORTS) {
-                        for (const prop of dataProps) {
-                            const propName = prop.getName();
-                            const propType = prop.getTypeAtLocation(dtsFile);
-                            ports.push({
-                                name: propName, defaultLabel: capitalize(propName), reference: propName,
-                                type: inferDataTypeFromTS(propType.getText()), direction: 'OUTPUT', defaultOrder: outputOrder++,
-                            });
-                        }
-                    }
-                    else {
-                        // Single result port: either primitive/array, or object with too many properties
-                        ports.push({
-                            name: 'result', defaultLabel: 'Result', reference: 'result',
-                            type: inferDataTypeFromTS(unwrapped), direction: 'OUTPUT', defaultOrder: outputOrder++,
-                        });
-                    }
-                }
-                nodeTypes.push({
-                    name: exportName,
-                    variant: 'FUNCTION',
-                    category: 'NPM Packages',
-                    function: exportName,
-                    label: exportName,
-                    importSource: packageName,
-                    ports,
-                    synchronicity: isAsync ? 'ASYNC' : 'SYNC',
-                    description: `${exportName} from ${packageName}`,
-                });
-            }
-        }
-        // Follow star re-exports (`export * from './submodule'`) which the symbol
-        // API surfaces as a single __export pseudo-symbol instead of individual names.
-        for (const exportDecl of dtsFile.getExportDeclarations()) {
-            if (!exportDecl.isNamespaceExport())
-                continue;
-            const targetFile = exportDecl.getModuleSpecifierSourceFile();
-            if (!targetFile)
-                continue;
-            const targetSymbol = targetFile.getSymbol();
-            if (!targetSymbol)
-                continue;
-            for (const exportSymbol of targetSymbol.getExports()) {
-                const exportName = exportSymbol.getName();
-                if (seenFunctionNames.has(exportName))
-                    continue;
-                const exportType = exportSymbol.getTypeAtLocation(targetFile);
-                const callSignatures = exportType.getCallSignatures();
-                if (callSignatures.length === 0)
-                    continue;
-                seenFunctionNames.add(exportName);
-                const sig = callSignatures[0];
-                const ports = [];
-                ports.push({ name: 'execute', defaultLabel: 'Execute', reference: 'execute', type: 'STEP', direction: 'INPUT', defaultOrder: 0 });
-                let starInputOrder = 1;
-                for (const param of sig.getParameters()) {
-                    const paramName = param.getName();
-                    const paramType = param.getTypeAtLocation(targetFile);
-                    ports.push({
-                        name: paramName, defaultLabel: capitalize(paramName), reference: paramName,
-                        type: inferDataTypeFromTS(paramType.getText()), direction: 'INPUT', defaultOrder: starInputOrder++,
-                    });
-                }
-                let returnType = sig.getReturnType();
-                const returnText = returnType.getText();
-                let isAsync = false;
-                if (returnText.startsWith('Promise<')) {
-                    isAsync = true;
-                    const typeArgs = returnType.getTypeArguments();
-                    if (typeArgs.length > 0)
-                        returnType = typeArgs[0];
-                }
-                ports.push({ name: 'onSuccess', defaultLabel: 'On Success', reference: 'onSuccess', type: 'STEP', direction: 'OUTPUT', defaultOrder: 0 });
-                ports.push({ name: 'onFailure', defaultLabel: 'On Failure', reference: 'onFailure', type: 'STEP', direction: 'OUTPUT', defaultOrder: 1, failure: true });
-                const unwrapped = returnType.getText();
-                if (unwrapped !== 'void' && unwrapped !== 'undefined' && unwrapped !== 'never') {
-                    ports.push({ name: 'result', defaultLabel: 'Result', reference: 'result', type: inferDataTypeFromTS(unwrapped), direction: 'OUTPUT', defaultOrder: 2 });
-                }
-                nodeTypes.push({
-                    name: exportName,
-                    variant: 'FUNCTION',
-                    category: 'NPM Packages',
-                    function: exportName,
-                    label: exportName,
-                    importSource: packageName,
-                    ports,
-                    synchronicity: isAsync ? 'ASYNC' : 'SYNC',
-                    description: `${exportName} from ${packageName}`,
-                });
-            }
-        }
-        // Fallback: if symbol-based enumeration found nothing, try extractFunctionLikes
-        // (handles edge cases where symbols aren't available)
-        if (nodeTypes.length === 0) {
-            const functions = extractFunctionLikes(dtsFile);
-            for (const fn of functions) {
-                const fnName = fn.getName();
-                if (!fnName || seenFunctionNames.has(fnName))
-                    continue;
-                seenFunctionNames.add(fnName);
-                const nodeType = inferNodeTypeFromDtsFunction(fn, packageName);
-                if (nodeType)
-                    nodeTypes.push(nodeType);
-            }
-        }
-        // Clean up added source files to avoid project bloat
-        for (const filePath of addedFiles) {
-            const sf = project.getSourceFile(filePath);
-            if (sf)
-                project.removeSourceFile(sf);
-        }
-        return nodeTypes;
-    }
-    catch {
-        return [];
-    }
-}
-//# sourceMappingURL=npm-packages.js.map
+import {
+  getPackageExports,
+  getTypedPackages
+} from "./chunks/chunk-B6HQ6YS5.js";
+import "./chunks/chunk-E5WN7IGO.js";
+import "./chunks/chunk-SEWDMQ6Q.js";
+export {
+  getPackageExports,
+  getTypedPackages
+};

package/dist/parser/annotation-parser.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The parser's entry points and the state they share.
+ *
+ * Decides what one parse of a file is: which cache answers it (the parse cache
+ * by mtime, then by content hash, both only while every file the parse read is
+ * unchanged), the order its node types are gathered in (local, imported,
+ * same-file workflows, caller-supplied externals, then inferred from
+ * unannotated functions), and when source files are added to and removed from
+ * the ts-morph Project. The work itself lives in the modules this one imports:
+ * `import-resolution` (imports and `@fwImport`), `workflow-extraction`
+ * (workflow ASTs and macros), `external-node-types`, `module-resolution`,
+ * `annotation-suggestion` (the editor suggestion) and `pack-handlers`.
+ */
+import type { Project } from 'ts-morph';
+import type { TNodeTypeAST, TWorkflowAST } from '../ast/types';
+import { type TagHandlerRegistry } from './tag-registry';
+import { type SourceImportResolver, type SourceOverrideLoader } from './module-resolution';
+import { type TExternalNodeType } from './external-node-types';
+export type { TExternalNodeType } from './external-node-types';
+export type { SourceImportResolver, SourceOverrideLoader } from './module-resolution';
+export { resolveNpmNodeTypes } from './npm-node-types';
+export interface ParseResult {
+    workflows: TWorkflowAST[];
+    nodeTypes: TNodeTypeAST[];
+    errors: string[];
+    warnings: string[];
+}
+export declare class AnnotationParser {
+    private project;
+    private importCache;
+    private importStack;
+    private parseCache;
+    /**
+     * Dependency recorders for the parses in progress: the outer entry belongs to
+     * the workflow file, and each imported file being processed pushes its own so
+     * its importCache entry can list what it read. A file read while any recorder
+     * is active is added to all of them.
+     */
+    private dependencyRecorders;
+    /** Tag handler registry. Defaults to the global singleton (pre-populated by extensions). */
+    tagRegistry: TagHandlerRegistry;
+    /** Tracks which projectDirs have already had their pack handlers loaded. */
+    private loadedPackDirs;
+    constructor(project?: Project);
+    /**
+     * Discover and register tag handlers from installed marketplace packs.
+     * Results are cached per projectDir so repeated parse calls skip the scan.
+     */
+    loadPackHandlers(projectDir: string): Promise<void>;
+    private computeHash;
+    /** The import state this parser shares with the import resolution functions. */
+    private importContext;
+    parse(filePath: string, externalNodeTypes?: TExternalNodeType[]): ParseResult;
+    /**
+     * Parse an in-memory source override at its real filesystem path. Relative
+     * imports resolve exactly as they do for parse(), but the override is never
+     * written to disk or stored in the parse cache.
+     */
+    parseSourceAtPath(filePath: string, content: string, externalNodeTypes?: TExternalNodeType[], importResolver?: SourceImportResolver, sourceLoader?: SourceOverrideLoader): ParseResult;
+    private fullParse;
+    /**
+     * Parse workflow from a string instead of a file path.
+     * Useful for testing and in-memory operations.
+     *
+     * Note: Imports from other workflow files are NOT supported in this mode
+     * since there's no filesystem context. Use parse() for files with imports.
+     *
+     * @param code - TypeScript source code containing workflow definitions
+     * @param virtualPath - Virtual file path for error messages (default: 'virtual.ts')
+     * @returns ParseResult with workflows and nodeTypes
+     */
+    parseFromString(code: string, virtualPath?: string): ParseResult;
+    clearCache(): void;
+    /** Clear only the parse result cache, keeping the import/node-type cache intact. */
+    clearParseCache(): void;
+    /**
+     * Suggest the `@flowWeaver` JSDoc for the function at or below `cursorLine`
+     * (0-based) in `content`. Returns the text to insert and where, or null when
+     * there is nothing to suggest.
+     */
+    generateAnnotationSuggestion(content: string, cursorLine: number, virtualPath?: string): {
+        text: string;
+        insertLine: number;
+        replaceLinesCount: number;
+    } | null;
+}
+export declare const parser: AnnotationParser;
+//# sourceMappingURL=annotation-parser.d.ts.map

package/dist/parser/annotation-suggestion.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The editor-facing annotation suggestion: given a file and a cursor line,
+ * the JSDoc text to insert for the function at or below the cursor.
+ *
+ * Decides which function the cursor targets, whether to suggest at all (never
+ * over a plain JSDoc the user wrote), the ports the signature implies that the
+ * existing annotation lacks, `@connect` lines between same-named ports of a
+ * workflow's nodes, and where the text goes (a full block above the function,
+ * the continuation of a just-typed JSDoc opener, or lines appended to the end
+ * of an existing block).
+ */
+import type { Project } from 'ts-morph';
+/**
+ * Suggest the `@flowWeaver` JSDoc for the function at or below `cursorLine`
+ * (0-based) in `content`, parsed as `virtualPath` in `project`. Returns null
+ * when there is nothing to suggest.
+ */
+export declare function generateAnnotationSuggestion(project: Project, content: string, cursorLine: number, virtualPath?: string): {
+    text: string;
+    insertLine: number;
+    replaceLinesCount: number;
+} | null;
+//# sourceMappingURL=annotation-suggestion.d.ts.map

package/dist/parser/durable-effect-contract.d.ts

@@ -0,0 +1,10 @@
+import type { TNodeTypeAST } from '../ast/types';
+import type { FunctionLike } from './function-like';
+export interface DurableEffectContractAnalysis {
+    readonly valid: boolean;
+    readonly diagnostics: string[];
+}
+export declare function hasJsDocTag(fn: FunctionLike, tagName: string): boolean;
+export declare function durableGateKind(fn: FunctionLike): 'approval' | 'input' | 'agent' | 'timer' | undefined;
+export declare function analyzeDurableEffectContract(fn: FunctionLike, inputs: TNodeTypeAST['inputs'], outputs: TNodeTypeAST['outputs']): DurableEffectContractAnalysis;
+//# sourceMappingURL=durable-effect-contract.d.ts.map