@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/marketplace/manifest.js

@@ -1,194 +0,0 @@
-/**
- * Manifest generation — converts parsed ASTs into a flowweaver.manifest.json file.
- *
- * The manifest mirrors AST types so the editor can consume it directly
- * without re-parsing source files.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import { AnnotationParser } from '../parser.js';
-// ── Port mapping ─────────────────────────────────────────────────────────────
-function toManifestPort(port) {
-    return {
-        dataType: port.dataType,
-        ...(port.description && { description: port.description }),
-        ...(port.optional && { optional: true }),
-    };
-}
-function toManifestPortFromPattern(port) {
-    return {
-        dataType: port.dataType ?? 'ANY',
-        ...(port.description && { description: port.description }),
-    };
-}
-function toManifestPorts(ports) {
-    const result = {};
-    for (const [name, def] of Object.entries(ports)) {
-        result[name] = toManifestPort(def);
-    }
-    return result;
-}
-// ── AST → Manifest mapping ──────────────────────────────────────────────────
-function nodeTypeToManifest(nt, relativeFile) {
-    return {
-        name: nt.name,
-        ...(nt.description && { description: nt.description }),
-        file: relativeFile,
-        functionName: nt.functionName,
-        isAsync: nt.isAsync,
-        inputs: toManifestPorts(nt.inputs),
-        outputs: toManifestPorts(nt.outputs),
-        ...(nt.visuals && {
-            visuals: {
-                ...(nt.visuals.color && { color: nt.visuals.color }),
-                ...(nt.visuals.icon && { icon: nt.visuals.icon }),
-                ...(nt.visuals.tags && { tags: nt.visuals.tags }),
-            },
-        }),
-    };
-}
-function workflowToManifest(wf, relativeFile) {
-    return {
-        name: wf.name,
-        ...(wf.description && { description: wf.description }),
-        file: relativeFile,
-        functionName: wf.functionName,
-        startPorts: toManifestPorts(wf.startPorts),
-        exitPorts: toManifestPorts(wf.exitPorts),
-        nodeCount: wf.instances.length,
-        connectionCount: wf.connections.length,
-    };
-}
-function patternToManifest(pat, relativeFile) {
-    const inputPorts = {};
-    for (const [name, def] of Object.entries(pat.inputPorts)) {
-        inputPorts[name] = toManifestPortFromPattern(def);
-    }
-    const outputPorts = {};
-    for (const [name, def] of Object.entries(pat.outputPorts)) {
-        outputPorts[name] = toManifestPortFromPattern(def);
-    }
-    return {
-        name: pat.name,
-        ...(pat.description && { description: pat.description }),
-        file: relativeFile,
-        inputPorts,
-        outputPorts,
-        nodeCount: pat.instances.length,
-    };
-}
-/**
- * Generate a marketplace manifest by parsing all annotated source files
- * in the package directory.
- */
-export async function generateManifest(options) {
-    const { directory, srcDir = 'src', distDir = 'dist' } = options;
-    // Read package.json
-    const pkgPath = path.join(directory, 'package.json');
-    if (!fs.existsSync(pkgPath)) {
-        return {
-            manifest: emptyManifest('unknown', '0.0.0'),
-            parsedFiles: [],
-            errors: ['package.json not found'],
-        };
-    }
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    const srcRoot = path.join(directory, srcDir);
-    // Find all TypeScript files in src/
-    const pattern = path.join(srcRoot, '**/*.ts').replace(/\\/g, '/');
-    const files = await glob(pattern, { absolute: true });
-    const tsFiles = files.filter((f) => !f.endsWith('.d.ts') && !f.includes('node_modules'));
-    const parser = new AnnotationParser();
-    const allNodeTypes = [];
-    const allWorkflows = [];
-    const allPatterns = [];
-    const errors = [];
-    const parsedFiles = [];
-    for (const file of tsFiles) {
-        try {
-            const result = parser.parse(file);
-            parsedFiles.push(file);
-            // Map source paths to dist paths: src/foo/bar.ts → dist/foo/bar.js
-            const relFromSrc = path.relative(srcRoot, file);
-            const distRelative = path.join(distDir, relFromSrc.replace(/\.ts$/, '.js'));
-            // Collect standalone node types (not embedded in workflows)
-            for (const nt of result.nodeTypes) {
-                allNodeTypes.push(nodeTypeToManifest(nt, distRelative));
-            }
-            // Collect workflows
-            for (const wf of result.workflows) {
-                allWorkflows.push(workflowToManifest(wf, distRelative));
-            }
-            // Collect patterns
-            for (const pat of result.patterns) {
-                allPatterns.push(patternToManifest(pat, distRelative));
-            }
-            if (result.errors.length > 0) {
-                errors.push(...result.errors.map((e) => `${file}: ${e}`));
-            }
-        }
-        catch (err) {
-            errors.push(`Failed to parse ${file}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // Preserve v2 extension fields from the existing manifest so that
-    // re-running pack:manifest doesn't wipe manually declared tagHandlers,
-    // validationRuleSets, docs, exportTargets, initContributions, etc.
-    const existing = readManifest(directory);
-    const v2Fields = {};
-    if (existing) {
-        if (existing.tagHandlers)
-            v2Fields.tagHandlers = existing.tagHandlers;
-        if (existing.validationRuleSets)
-            v2Fields.validationRuleSets = existing.validationRuleSets;
-        if (existing.exportTargets)
-            v2Fields.exportTargets = existing.exportTargets;
-        if (existing.docs)
-            v2Fields.docs = existing.docs;
-        if (existing.initContributions)
-            v2Fields.initContributions = existing.initContributions;
-    }
-    const manifest = {
-        manifestVersion: 2,
-        name: pkg.name ?? 'unknown',
-        version: pkg.version ?? '0.0.0',
-        ...(pkg.description && { description: pkg.description }),
-        ...(pkg.flowWeaver?.engineVersion && { engineVersion: pkg.flowWeaver.engineVersion }),
-        ...(pkg.flowWeaver?.categories && { categories: pkg.flowWeaver.categories }),
-        nodeTypes: allNodeTypes,
-        workflows: allWorkflows,
-        patterns: allPatterns,
-        ...v2Fields,
-        ...(Object.keys(pkg.dependencies ?? {}).length > 0 && {
-            dependencies: {
-                npm: pkg.dependencies,
-            },
-        }),
-    };
-    return { manifest, parsedFiles, errors };
-}
-/** Write manifest JSON to disk. */
-export function writeManifest(directory, manifest) {
-    const outPath = path.join(directory, 'flowweaver.manifest.json');
-    fs.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
-    return outPath;
-}
-/** Read manifest JSON from disk. */
-export function readManifest(directory) {
-    const manifestPath = path.join(directory, 'flowweaver.manifest.json');
-    if (!fs.existsSync(manifestPath))
-        return null;
-    return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-}
-function emptyManifest(name, version) {
-    return {
-        manifestVersion: 2,
-        name,
-        version,
-        nodeTypes: [],
-        workflows: [],
-        patterns: [],
-    };
-}
-//# sourceMappingURL=manifest.js.map

package/dist/marketplace/registry.js

@@ -1,198 +0,0 @@
-/**
- * Registry integration — npm search API + local package scanning.
- *
- * Uses the npm registry search endpoint filtered by the
- * `flow-weaver-marketplace-pack` keyword for discovery, and scans
- * `node_modules/` for locally installed packages.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-const MARKETPLACE_KEYWORD = 'flow-weaver-marketplace-pack';
-const NPM_SEARCH_URL = 'https://registry.npmjs.org/-/v1/search';
-const PACK_NAME_RE = /^(@[^/]+\/)?flow-weaver-pack-.+$/;
-/**
- * Search the npm registry for marketplace packages.
- */
-export async function searchPackages(options = {}) {
-    const { query, limit = 20, registryUrl } = options;
-    // Build search query: always filter by marketplace keyword
-    const textParts = [
-        `keywords:${MARKETPLACE_KEYWORD}`,
-        ...(query ? [query] : []),
-    ];
-    const url = new URL(registryUrl ?? NPM_SEARCH_URL);
-    url.searchParams.set('text', textParts.join(' '));
-    url.searchParams.set('size', String(limit));
-    const response = await fetch(url.toString());
-    if (!response.ok) {
-        throw new Error(`npm search failed: ${response.status} ${response.statusText}`);
-    }
-    const data = (await response.json());
-    return data.objects
-        .filter((obj) => PACK_NAME_RE.test(obj.package.name))
-        .map((obj) => ({
-        name: obj.package.name,
-        version: obj.package.version,
-        description: obj.package.description,
-        keywords: obj.package.keywords,
-        publisher: obj.package.publisher?.username,
-        official: obj.package.name.startsWith('@synergenius/'),
-    }));
-}
-// ── Local scanning ───────────────────────────────────────────────────────────
-/**
- * Scan node_modules for installed marketplace packages by looking for
- * `flowweaver.manifest.json` files in matching package directories.
- */
-export async function listInstalledPackages(projectDir) {
-    const nodeModules = path.join(projectDir, 'node_modules');
-    if (!fs.existsSync(nodeModules))
-        return [];
-    // Look for flow-weaver-pack-* and @*/flow-weaver-pack-* directories
-    const patterns = [
-        path.join(nodeModules, 'flow-weaver-pack-*', 'flowweaver.manifest.json'),
-        path.join(nodeModules, '@*', 'flow-weaver-pack-*', 'flowweaver.manifest.json'),
-    ];
-    const results = [];
-    for (const pattern of patterns) {
-        const manifestPaths = await glob(pattern.replace(/\\/g, '/'), { absolute: true });
-        for (const manifestPath of manifestPaths) {
-            try {
-                const pkgDir = path.dirname(manifestPath);
-                const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-                // Also read package.json for accurate version
-                const pkgJsonPath = path.join(pkgDir, 'package.json');
-                let version = manifest.version;
-                if (fs.existsSync(pkgJsonPath)) {
-                    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
-                    version = pkg.version ?? manifest.version;
-                }
-                results.push({
-                    name: manifest.name,
-                    version,
-                    manifest,
-                    path: pkgDir,
-                });
-            }
-            catch {
-                // Skip malformed manifests
-            }
-        }
-    }
-    return results;
-}
-/**
- * Read the manifest for a specific installed package.
- */
-export function getInstalledPackageManifest(projectDir, packageName) {
-    const packageDir = path.join(projectDir, 'node_modules', packageName);
-    const manifestPath = path.join(packageDir, 'flowweaver.manifest.json');
-    if (!fs.existsSync(manifestPath))
-        return null;
-    try {
-        return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Discover all tag handlers from installed pack manifests.
- */
-export async function discoverTagHandlers(projectDir) {
-    const packages = await listInstalledPackages(projectDir);
-    const handlers = [];
-    for (const pkg of packages) {
-        const manifest = pkg.manifest;
-        if (!manifest.tagHandlers)
-            continue;
-        for (const handler of manifest.tagHandlers) {
-            handlers.push({
-                ...handler,
-                absoluteFile: path.join(pkg.path, handler.file),
-                packageName: pkg.name,
-            });
-        }
-    }
-    return handlers;
-}
-/**
- * Discover all validation rule sets from installed pack manifests.
- */
-export async function discoverValidationRuleSets(projectDir) {
-    const packages = await listInstalledPackages(projectDir);
-    const ruleSets = [];
-    for (const pkg of packages) {
-        const manifest = pkg.manifest;
-        if (!manifest.validationRuleSets)
-            continue;
-        for (const ruleSet of manifest.validationRuleSets) {
-            ruleSets.push({
-                ...ruleSet,
-                absoluteFile: path.join(pkg.path, ruleSet.file),
-                packageName: pkg.name,
-            });
-        }
-    }
-    return ruleSets;
-}
-/**
- * Discover all doc topics from installed pack manifests.
- */
-export async function discoverDocTopics(projectDir) {
-    const packages = await listInstalledPackages(projectDir);
-    const topics = [];
-    for (const pkg of packages) {
-        const manifest = pkg.manifest;
-        if (!manifest.docs)
-            continue;
-        for (const doc of manifest.docs) {
-            topics.push({
-                ...doc,
-                absoluteFile: path.join(pkg.path, doc.file),
-                packageName: pkg.name,
-            });
-        }
-    }
-    return topics;
-}
-/**
- * Discover all init contributions from installed pack manifests.
- */
-export async function discoverInitContributions(projectDir) {
-    const packages = await listInstalledPackages(projectDir);
-    const contributions = [];
-    for (const pkg of packages) {
-        const manifest = pkg.manifest;
-        if (!manifest.initContributions)
-            continue;
-        contributions.push({
-            ...manifest.initContributions,
-            packageName: pkg.name,
-        });
-    }
-    return contributions;
-}
-/**
- * Discover all device handler entry points from installed pack manifests.
- *
- * Returns packs that declare a `deviceHandlers` field in their manifest,
- * resolved to an absolute entrypoint path.
- */
-export async function discoverDeviceHandlers(projectDir) {
-    const packages = await listInstalledPackages(projectDir);
-    const handlers = [];
-    for (const pkg of packages) {
-        const manifest = pkg.manifest;
-        if (!manifest.deviceHandlers)
-            continue;
-        handlers.push({
-            packageName: pkg.name,
-            packagePath: pkg.path,
-            entrypoint: path.join(pkg.path, manifest.deviceHandlers),
-        });
-    }
-    return handlers;
-}
-//# sourceMappingURL=registry.js.map

package/dist/marketplace/types.js

@@ -1,9 +0,0 @@
-/**
- * Marketplace types for Flow Weaver package distribution.
- *
- * Packages follow the naming convention `flow-weaver-pack-*` and use
- * npm as the distribution backbone. The manifest is auto-generated
- * from source annotations via the parser.
- */
-export {};
-//# sourceMappingURL=types.js.map

package/dist/marketplace/validator.js

@@ -1,150 +0,0 @@
-/**
- * Package validation — checks that a marketplace package meets
- * all requirements before publishing.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseWorkflow, validateWorkflow } from '../api/index.js';
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function issue(code, severity, message) {
-    return { code, severity, message };
-}
-const PACK_NAME_RE = /^(@[^/]+\/)?flow-weaver-pack-.+$/;
-const MARKETPLACE_KEYWORD = 'flow-weaver-marketplace-pack';
-// ── Package-level rules ──────────────────────────────────────────────────────
-function validatePackageJson(pkg, directory) {
-    const issues = [];
-    // PKG-005: Name must match flow-weaver-pack-* or @*/flow-weaver-pack-*
-    const name = pkg.name;
-    if (!name || !PACK_NAME_RE.test(name)) {
-        issues.push(issue('PKG-005', 'error', `Package name must match "flow-weaver-pack-*" or "@<scope>/flow-weaver-pack-*", got "${name ?? ''}"`));
-    }
-    // PKG-001: keywords must include flow-weaver-marketplace-pack
-    const keywords = (pkg.keywords ?? []);
-    if (!keywords.includes(MARKETPLACE_KEYWORD)) {
-        issues.push(issue('PKG-001', 'error', `"keywords" must include "${MARKETPLACE_KEYWORD}"`));
-    }
-    // PKG-002: flowWeaver.engineVersion must be set
-    const fw = pkg.flowWeaver;
-    if (!fw?.engineVersion) {
-        issues.push(issue('PKG-002', 'error', '"flowWeaver.engineVersion" must be set in package.json'));
-    }
-    // PKG-003: peerDependencies must include @synergenius/flow-weaver
-    const peers = (pkg.peerDependencies ?? {});
-    if (!peers['@synergenius/flow-weaver']) {
-        issues.push(issue('PKG-003', 'error', '"peerDependencies" must include "@synergenius/flow-weaver"'));
-    }
-    // PKG-004: Must not be private
-    if (pkg.private === true) {
-        issues.push(issue('PKG-004', 'error', 'Package must not be "private: true"'));
-    }
-    // PKG-007: README.md should exist
-    if (!fs.existsSync(path.join(directory, 'README.md'))) {
-        issues.push(issue('PKG-007', 'warning', 'README.md should exist'));
-    }
-    return issues;
-}
-// ── Manifest-level rules ─────────────────────────────────────────────────────
-function validateManifestContents(manifest) {
-    const issues = [];
-    const totalUnits = manifest.nodeTypes.length + manifest.workflows.length + manifest.patterns.length +
-        (manifest.exportTargets?.length ?? 0);
-    // PKG-006: Must contain at least one unit
-    if (totalUnits === 0) {
-        issues.push(issue('PKG-006', 'error', 'Package must contain at least one node type, workflow, pattern, or export target'));
-    }
-    // TGT-001: Export target entries must have name and file
-    for (const et of manifest.exportTargets ?? []) {
-        if (!et.name) {
-            issues.push(issue('TGT-001', 'error', 'Export target entry must have a "name"'));
-        }
-        if (!et.file) {
-            issues.push(issue('TGT-001', 'error', `Export target "${et.name || '(unnamed)'}" must have a "file"`));
-        }
-    }
-    // TGT-002: Export target names must be unique within the package
-    const etNames = new Set();
-    for (const et of manifest.exportTargets ?? []) {
-        if (et.name && etNames.has(et.name)) {
-            issues.push(issue('TGT-002', 'error', `Duplicate export target name: "${et.name}"`));
-        }
-        if (et.name)
-            etNames.add(et.name);
-    }
-    // UNIT-002: Node type names must be unique within the package
-    const ntNames = new Set();
-    for (const nt of manifest.nodeTypes) {
-        if (ntNames.has(nt.name)) {
-            issues.push(issue('UNIT-002', 'error', `Duplicate node type name: "${nt.name}"`));
-        }
-        ntNames.add(nt.name);
-    }
-    // PKG-008: All node types should have descriptions
-    for (const nt of manifest.nodeTypes) {
-        if (!nt.description) {
-            issues.push(issue('PKG-008', 'warning', `Node type "${nt.name}" should have a description`));
-        }
-    }
-    // PKG-009: All node types should have visuals
-    for (const nt of manifest.nodeTypes) {
-        if (!nt.visuals || (!nt.visuals.color && !nt.visuals.icon && !nt.visuals.tags)) {
-            issues.push(issue('PKG-009', 'warning', `Node type "${nt.name}" should have visuals (color, icon, or tags)`));
-        }
-    }
-    // UNIT-003: Patterns must have at least one IN or OUT port
-    for (const pat of manifest.patterns) {
-        const inCount = Object.keys(pat.inputPorts).length;
-        const outCount = Object.keys(pat.outputPorts).length;
-        if (inCount === 0 && outCount === 0) {
-            issues.push(issue('UNIT-003', 'error', `Pattern "${pat.name}" must have at least one IN or OUT port`));
-        }
-    }
-    return issues;
-}
-// ── Workflow validation (UNIT-001) ───────────────────────────────────────────
-async function validateWorkflows(manifest, directory) {
-    const issues = [];
-    for (const wf of manifest.workflows) {
-        // Resolve source file from dist path back to src
-        const srcFile = path.join(directory, wf.file.replace(/^dist\//, 'src/').replace(/\.js$/, '.ts'));
-        if (!fs.existsSync(srcFile))
-            continue;
-        try {
-            const parseResult = await parseWorkflow(srcFile, { workflowName: wf.functionName });
-            if (parseResult.errors.length > 0)
-                continue; // Parse errors reported by pack command
-            const result = validateWorkflow(parseResult.ast);
-            if (result.errors.length > 0) {
-                issues.push(issue('UNIT-001', 'error', `Workflow "${wf.name}" has validation errors: ${result.errors.map((e) => e.message).join('; ')}`));
-            }
-        }
-        catch {
-            // If parsing fails entirely, the pack command will already have reported the error
-        }
-    }
-    return issues;
-}
-// ── Public API ───────────────────────────────────────────────────────────────
-/**
- * Validate a marketplace package directory.
- *
- * Checks package.json fields, manifest contents, and individual workflow validity.
- */
-export async function validatePackage(directory, manifest) {
-    const pkgPath = path.join(directory, 'package.json');
-    if (!fs.existsSync(pkgPath)) {
-        return {
-            valid: false,
-            issues: [issue('PKG-000', 'error', 'package.json not found')],
-        };
-    }
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    const issues = [
-        ...validatePackageJson(pkg, directory),
-        ...validateManifestContents(manifest),
-        ...(await validateWorkflows(manifest, directory)),
-    ];
-    const valid = !issues.some((i) => i.severity === 'error');
-    return { valid, issues };
-}
-//# sourceMappingURL=validator.js.map

package/dist/mcp/agent-channel.d.ts

@@ -1,35 +0,0 @@
-/**
- * AgentChannel provides Promise-based pause/resume for workflow execution.
- *
- * When a workflow hits a waitForAgent node, the node calls `request()` which
- * suspends execution on an unresolved Promise. The executor detects the pause
- * via `onPause()`, and later calls `resume()` to resolve the Promise and
- * continue execution from exactly where it paused.
- */
-export declare class AgentChannel {
-    private _resolve;
-    private _reject;
-    private _pauseResolve;
-    private _pausePromise;
-    constructor();
-    /**
-     * Called by the waitForAgent node to suspend execution.
-     * Returns a Promise that resolves when `resume()` is called.
-     */
-    request(agentRequest: object): Promise<object>;
-    /**
-     * Awaited by the executor to detect when the workflow pauses.
-     * Resolves with the agent request data from `request()`.
-     */
-    onPause(): Promise<object>;
-    /**
-     * Called by fw_resume_workflow to continue execution with the agent's result.
-     */
-    resume(result: object): void;
-    /**
-     * Called to fail a pending wait with an error.
-     */
-    fail(reason: string): void;
-    private _createPausePromise;
-}
-//# sourceMappingURL=agent-channel.d.ts.map

package/dist/mcp/agent-channel.js

@@ -1,61 +0,0 @@
-/**
- * AgentChannel provides Promise-based pause/resume for workflow execution.
- *
- * When a workflow hits a waitForAgent node, the node calls `request()` which
- * suspends execution on an unresolved Promise. The executor detects the pause
- * via `onPause()`, and later calls `resume()` to resolve the Promise and
- * continue execution from exactly where it paused.
- */
-export class AgentChannel {
-    _resolve = null;
-    _reject = null;
-    _pauseResolve = null;
-    _pausePromise;
-    constructor() {
-        this._pausePromise = this._createPausePromise();
-    }
-    /**
-     * Called by the waitForAgent node to suspend execution.
-     * Returns a Promise that resolves when `resume()` is called.
-     */
-    async request(agentRequest) {
-        // Signal the executor that we're pausing
-        this._pauseResolve?.(agentRequest);
-        // Suspend on a new Promise until resume() or fail() is called
-        return new Promise((resolve, reject) => {
-            this._resolve = resolve;
-            this._reject = reject;
-        });
-    }
-    /**
-     * Awaited by the executor to detect when the workflow pauses.
-     * Resolves with the agent request data from `request()`.
-     */
-    onPause() {
-        return this._pausePromise;
-    }
-    /**
-     * Called by fw_resume_workflow to continue execution with the agent's result.
-     */
-    resume(result) {
-        this._resolve?.(result);
-        this._resolve = null;
-        this._reject = null;
-        this._pausePromise = this._createPausePromise();
-    }
-    /**
-     * Called to fail a pending wait with an error.
-     */
-    fail(reason) {
-        this._reject?.(new Error(reason));
-        this._resolve = null;
-        this._reject = null;
-        this._pausePromise = this._createPausePromise();
-    }
-    _createPausePromise() {
-        return new Promise((resolve) => {
-            this._pauseResolve = resolve;
-        });
-    }
-}
-//# sourceMappingURL=agent-channel.js.map

package/dist/mcp/auto-registration.d.ts

@@ -1,3 +0,0 @@
-import type { McpServerOptions, RegistrationDeps } from './types.js';
-export declare function offerClaudeRegistration(options: McpServerOptions, deps?: RegistrationDeps): Promise<void>;
-//# sourceMappingURL=auto-registration.d.ts.map