@zokizuan/satori-mcp 6.2.0 → 6.3.0

package/dist/server/shared-runtime-host.js

@@ -0,0 +1,322 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import { createMcpConfig, resolveMcpRuntimeBootstrap, } from "../config.js";
+import { SHARED_RUNTIME_HANDSHAKE_MAX_BYTES, SHARED_RUNTIME_IDLE_MS, SHARED_RUNTIME_PROTOCOL_VERSION, buildSharedRuntimeIdentity, isSharedOfflineRuntimeEligible, resolveSharedRuntimePaths, } from "./shared-runtime-identity.js";
+import { acquireLifecycleLock, readHostMetadata, readLinuxProcessIdentity, removeOwnedLifecycleState, writeHostMetadataAtomic, } from "./shared-runtime-lifecycle.js";
+import { SharedRuntimeHost } from "./shared-runtime.js";
+import { BoundedSocketTransport } from "./shared-runtime-transport.js";
+function parseAttachRequest(line) {
+    try {
+        const value = JSON.parse(line);
+        if (value.type !== "satori-shared-runtime-attach"
+            || typeof value.protocolVersion !== "number"
+            || typeof value.sharedRuntimeIdentityHash !== "string"
+            || typeof value.installedRuntimeRoot !== "string"
+            || typeof value.mcpVersion !== "string"
+            || typeof value.launcherNonce !== "string"
+            || !/^[a-f0-9]{48}$/.test(value.launcherNonce)) {
+            return null;
+        }
+        return Object.freeze(value);
+    }
+    catch {
+        return null;
+    }
+}
+export class SharedRuntimeSocketHost {
+    constructor(runtimeHost, identity, paths, idleMs = SHARED_RUNTIME_IDLE_MS) {
+        this.runtimeHost = runtimeHost;
+        this.identity = identity;
+        this.paths = paths;
+        this.idleMs = idleMs;
+        this.sessions = new Set();
+        this.ownershipToken = crypto.randomUUID();
+        this.metadata = null;
+        this.idleTimer = null;
+        this.closing = false;
+        this.server = net.createServer({ pauseOnConnect: true }, (socket) => {
+            this.cancelIdleShutdown();
+            this.acceptHandshake(socket);
+        });
+        this.unsubscribeActivity = this.runtimeHost.subscribeActivity(() => {
+            const activity = this.runtimeHost.getActivity();
+            if (activity.sessions > 0 || activity.operations > 0) {
+                this.cancelIdleShutdown();
+            }
+            else {
+                this.scheduleIdleShutdown();
+            }
+        });
+    }
+    async start() {
+        let boundSocket = null;
+        try {
+            await this.runtimeHost.recoverInterruptedIndexingAtStartup();
+            await new Promise((resolve, reject) => {
+                const onError = (error) => {
+                    this.server.off("listening", onListening);
+                    reject(error);
+                };
+                const onListening = () => {
+                    this.server.off("error", onError);
+                    resolve();
+                };
+                this.server.once("error", onError);
+                this.server.once("listening", onListening);
+                this.server.listen(this.paths.socketPath);
+            });
+            const socketStat = fs.lstatSync(this.paths.socketPath);
+            boundSocket = Object.freeze({
+                device: socketStat.dev,
+                inode: socketStat.ino,
+            });
+            fs.chmodSync(this.paths.socketPath, 0o600);
+            const processIdentity = readLinuxProcessIdentity();
+            if (!processIdentity) {
+                throw new Error("Cannot establish shared runtime host process identity.");
+            }
+            this.metadata = Object.freeze({
+                formatVersion: 1,
+                protocolVersion: SHARED_RUNTIME_PROTOCOL_VERSION,
+                hostPid: processIdentity.pid,
+                bootId: processIdentity.bootId,
+                processStartTime: processIdentity.startTime,
+                mcpVersion: this.identity.mcpVersion,
+                sharedRuntimeIdentityHash: this.identity.hash,
+                installedRuntimeRoot: this.identity.installedRuntimeRoot,
+                ownershipToken: this.ownershipToken,
+                socketPath: this.paths.socketPath,
+                socketDevice: socketStat.dev,
+                socketInode: socketStat.ino,
+                readyAt: new Date().toISOString(),
+            });
+            writeHostMetadataAtomic(this.paths.metadataPath, this.metadata);
+            try {
+                fs.unlinkSync(this.paths.errorPath);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            this.scheduleIdleShutdown();
+        }
+        catch (error) {
+            this.closing = true;
+            if (this.server.listening) {
+                await new Promise((resolve) => {
+                    this.server.close(() => resolve());
+                });
+            }
+            if (boundSocket) {
+                try {
+                    const current = fs.lstatSync(this.paths.socketPath);
+                    if (current.isSocket()
+                        && current.dev === boundSocket.device
+                        && current.ino === boundSocket.inode) {
+                        fs.unlinkSync(this.paths.socketPath);
+                    }
+                }
+                catch {
+                    // The launcher owns stale-path recovery. Startup cleanup
+                    // must still release provider and runtime-owner state.
+                }
+            }
+            this.unsubscribeActivity();
+            await this.runtimeHost.shutdown().catch(() => undefined);
+            throw error;
+        }
+    }
+    acceptHandshake(socket) {
+        let buffered = Buffer.alloc(0);
+        const timer = setTimeout(() => {
+            cleanup();
+            socket.destroy();
+            this.scheduleIdleShutdown();
+        }, 10000);
+        const cleanup = () => {
+            clearTimeout(timer);
+            socket.off("data", onData);
+            socket.off("error", onError);
+            socket.off("close", onClose);
+        };
+        const onError = () => {
+            cleanup();
+            this.scheduleIdleShutdown();
+        };
+        const onClose = () => {
+            cleanup();
+            this.scheduleIdleShutdown();
+        };
+        const reject = (message) => {
+            const response = {
+                type: "satori-shared-runtime-attached",
+                accepted: false,
+                protocolVersion: SHARED_RUNTIME_PROTOCOL_VERSION,
+                sharedRuntimeIdentityHash: this.identity.hash,
+                installedRuntimeRoot: this.identity.installedRuntimeRoot,
+                mcpVersion: this.identity.mcpVersion,
+                hostPid: process.pid,
+                bootId: this.metadata?.bootId ?? "",
+                processStartTime: this.metadata?.processStartTime ?? "",
+                launcherNonce: "",
+                error: message,
+            };
+            socket.once("error", () => {
+                // A rejected peer owns no session state.
+            });
+            socket.end(`${JSON.stringify(response)}\n`, () => socket.destroy());
+            this.scheduleIdleShutdown();
+        };
+        const onData = (chunk) => {
+            if (buffered.length + chunk.length > SHARED_RUNTIME_HANDSHAKE_MAX_BYTES) {
+                cleanup();
+                reject("Attach handshake exceeded its byte limit.");
+                return;
+            }
+            buffered = buffered.length === 0
+                ? Buffer.from(chunk)
+                : Buffer.concat([buffered, chunk]);
+            const newline = buffered.indexOf(0x0a);
+            if (newline < 0)
+                return;
+            cleanup();
+            const request = parseAttachRequest(buffered.subarray(0, newline).toString("utf8"));
+            const trailing = buffered.subarray(newline + 1);
+            if (!request) {
+                reject("Attach handshake is malformed.");
+                return;
+            }
+            if (request.protocolVersion !== SHARED_RUNTIME_PROTOCOL_VERSION
+                || request.sharedRuntimeIdentityHash !== this.identity.hash
+                || request.installedRuntimeRoot !== this.identity.installedRuntimeRoot
+                || request.mcpVersion !== this.identity.mcpVersion) {
+                reject("Attach handshake runtime identity does not match this host.");
+                return;
+            }
+            if (!this.metadata || this.closing) {
+                reject("Shared runtime host is not accepting sessions.");
+                return;
+            }
+            const response = {
+                type: "satori-shared-runtime-attached",
+                accepted: true,
+                protocolVersion: SHARED_RUNTIME_PROTOCOL_VERSION,
+                sharedRuntimeIdentityHash: this.identity.hash,
+                installedRuntimeRoot: this.identity.installedRuntimeRoot,
+                mcpVersion: this.identity.mcpVersion,
+                hostPid: this.metadata.hostPid,
+                bootId: this.metadata.bootId,
+                processStartTime: this.metadata.processStartTime,
+                launcherNonce: request.launcherNonce,
+            };
+            socket.write(`${JSON.stringify(response)}\n`);
+            void this.attachSession(socket, trailing).catch(() => {
+                socket.destroy();
+                this.scheduleIdleShutdown();
+            });
+        };
+        socket.on("data", onData);
+        socket.once("error", onError);
+        socket.once("close", onClose);
+        socket.resume();
+    }
+    async attachSession(socket, trailing) {
+        if (this.closing) {
+            socket.destroy();
+            return;
+        }
+        const session = this.runtimeHost.createSession();
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            this.sessions.delete(session);
+            void session.shutdown().finally(() => this.scheduleIdleShutdown());
+        };
+        const transport = new BoundedSocketTransport(socket, release, trailing);
+        this.sessions.add(session);
+        try {
+            await session.connect(transport);
+        }
+        catch (error) {
+            this.sessions.delete(session);
+            socket.destroy();
+            await session.shutdown();
+            this.scheduleIdleShutdown();
+            throw error;
+        }
+    }
+    cancelIdleShutdown() {
+        if (!this.idleTimer)
+            return;
+        clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+    scheduleIdleShutdown() {
+        if (this.closing || this.sessions.size > 0 || this.idleTimer)
+            return;
+        const activity = this.runtimeHost.getActivity();
+        if (activity.sessions > 0 || activity.operations > 0)
+            return;
+        this.idleTimer = setTimeout(() => {
+            this.idleTimer = null;
+            void this.shutdown();
+        }, this.idleMs);
+        this.idleTimer.unref?.();
+    }
+    async shutdown() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        this.cancelIdleShutdown();
+        const lock = await acquireLifecycleLock(this.paths.lockPath);
+        try {
+            if (this.runtimeHost.getActivity().operations > 0) {
+                this.closing = false;
+                this.scheduleIdleShutdown();
+                return;
+            }
+            await new Promise((resolve) => {
+                this.server.close(() => resolve());
+            });
+            await Promise.all([...this.sessions].map((session) => session.shutdown()));
+            this.sessions.clear();
+            await this.runtimeHost.shutdown();
+            this.unsubscribeActivity();
+            if (this.metadata) {
+                removeOwnedLifecycleState(this.paths, this.metadata);
+            }
+        }
+        finally {
+            lock.release();
+        }
+    }
+}
+export async function startSharedRuntimeHostFromEnv() {
+    const runtimeEntry = process.env.SATORI_SHARED_RUNTIME_ENTRY
+        ?? process.argv[1];
+    if (!runtimeEntry) {
+        throw new Error("Shared runtime host requires its installed runtime entry path.");
+    }
+    if (!isSharedOfflineRuntimeEligible(process.env)) {
+        throw new Error("Shared runtime host requires managed offline Potion + LanceDB configuration.");
+    }
+    const identity = buildSharedRuntimeIdentity(runtimeEntry, process.env);
+    if (process.env.SATORI_SHARED_RUNTIME_EXPECTED_HASH !== identity.hash) {
+        throw new Error("Shared runtime host identity differs from the starting launcher.");
+    }
+    const paths = resolveSharedRuntimePaths(identity, process.env);
+    const existing = readHostMetadata(paths.metadataPath);
+    if (existing) {
+        throw new Error("Shared runtime host metadata already exists; launcher recovery must resolve it.");
+    }
+    const parsedConfig = createMcpConfig();
+    const { config, runtimeFingerprint } = await resolveMcpRuntimeBootstrap(parsedConfig);
+    const runtimeHost = new SharedRuntimeHost(config, runtimeFingerprint, "host");
+    const socketHost = new SharedRuntimeSocketHost(runtimeHost, identity, paths);
+    await socketHost.start();
+    return socketHost;
+}
+//# sourceMappingURL=shared-runtime-host.js.map

package/dist/server/shared-runtime-identity.d.ts

@@ -0,0 +1,51 @@
+export declare const SHARED_RUNTIME_PROTOCOL_VERSION = 1;
+export declare const SHARED_RUNTIME_HANDSHAKE_MAX_BYTES: number;
+export declare const SHARED_RUNTIME_MESSAGE_MAX_BYTES: number;
+export declare const SHARED_RUNTIME_MAX_PENDING_REQUESTS = 16;
+export declare const SHARED_RUNTIME_ATTACH_TIMEOUT_MS = 10000;
+export declare const SHARED_RUNTIME_IDLE_MS = 60000;
+export type SharedRuntimeIdentity = Readonly<{
+    protocolVersion: number;
+    mcpVersion: string;
+    installedRuntimeRoot: string;
+    stateRoot: string;
+    serverName: string;
+    serverVersion: string;
+    runtimeProfile: string;
+    embeddingProvider: string;
+    embeddingModel: string;
+    embeddingDimension: string;
+    hybridMode: string;
+    embeddingBatchSize: string;
+    potionHelperPath: string;
+    potionModelPath: string;
+    potionRequestTimeoutMs: string;
+    vectorStoreProvider: string;
+    lanceDbPath: string;
+    watcherEnabled: string;
+    watcherDebounceMs: string;
+    readFileMaxLines: string;
+    customExtensions: string;
+    customIgnorePatterns: string;
+    navigationBackend: string;
+    navigationDualRead: string;
+    allTextMaxBytes: string;
+    syncHashConcurrency: string;
+    syncFullHashEveryN: string;
+    sourceMeasurementLedger: string;
+    sourceMeasurementRoot: string;
+    hash: string;
+}>;
+export type SharedRuntimePaths = Readonly<{
+    stateRoot: string;
+    metadataDirectory: string;
+    metadataPath: string;
+    errorPath: string;
+    lockPath: string;
+    socketDirectory: string;
+    socketPath: string;
+}>;
+export declare function isSharedOfflineRuntimeEligible(env: NodeJS.ProcessEnv, platform?: NodeJS.Platform, architecture?: NodeJS.Architecture): boolean;
+export declare function buildSharedRuntimeIdentity(runtimeEntry: string, env: NodeJS.ProcessEnv): SharedRuntimeIdentity;
+export declare function resolveSharedRuntimePaths(identity: SharedRuntimeIdentity, env: NodeJS.ProcessEnv): SharedRuntimePaths;
+//# sourceMappingURL=shared-runtime-identity.d.ts.map

package/dist/server/shared-runtime-identity.js

@@ -0,0 +1,160 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const SHARED_RUNTIME_PROTOCOL_VERSION = 1;
+export const SHARED_RUNTIME_HANDSHAKE_MAX_BYTES = 16 * 1024;
+export const SHARED_RUNTIME_MESSAGE_MAX_BYTES = 8 * 1024 * 1024;
+export const SHARED_RUNTIME_MAX_PENDING_REQUESTS = 16;
+export const SHARED_RUNTIME_ATTACH_TIMEOUT_MS = 10000;
+export const SHARED_RUNTIME_IDLE_MS = 60000;
+function stableStringify(value) {
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${JSON.stringify(value[key])}`)
+        .join(",")}}`;
+}
+function canonicalizePath(candidatePath) {
+    const absolutePath = path.resolve(candidatePath);
+    let existingPath = absolutePath;
+    while (!fs.existsSync(existingPath)) {
+        const parent = path.dirname(existingPath);
+        if (parent === existingPath) {
+            return absolutePath;
+        }
+        existingPath = parent;
+    }
+    const canonicalExistingPath = fs.realpathSync(existingPath);
+    return path.resolve(canonicalExistingPath, path.relative(existingPath, absolutePath));
+}
+function readPackageVersion(runtimeEntry) {
+    let current = path.dirname(path.resolve(runtimeEntry));
+    for (;;) {
+        const packagePath = path.join(current, "package.json");
+        if (fs.existsSync(packagePath)) {
+            const parsed = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+            if (parsed.name === "@zokizuan/satori-mcp"
+                && typeof parsed.version === "string"
+                && parsed.version.length > 0) {
+                return {
+                    version: parsed.version,
+                    packageRoot: fs.realpathSync(current),
+                };
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new Error(`Cannot locate @zokizuan/satori-mcp package for '${runtimeEntry}'.`);
+}
+export function isSharedOfflineRuntimeEligible(env, platform = process.platform, architecture = process.arch) {
+    return env.SATORI_SHARED_RUNTIME_DISABLE !== "1"
+        && env.SATORI_RUNTIME_PROFILE === "offline"
+        && env.EMBEDDING_PROVIDER === "Potion"
+        && env.VECTOR_STORE_PROVIDER === "LanceDB"
+        && platform === "linux"
+        && architecture === "x64";
+}
+export function buildSharedRuntimeIdentity(runtimeEntry, env) {
+    const installed = readPackageVersion(runtimeEntry);
+    const stateRoot = canonicalizePath(env.SATORI_STATE_ROOT
+        ?? path.join(env.HOME ?? os.homedir(), ".satori"));
+    const payload = {
+        protocolVersion: SHARED_RUNTIME_PROTOCOL_VERSION,
+        mcpVersion: installed.version,
+        installedRuntimeRoot: installed.packageRoot,
+        stateRoot,
+        serverName: env.MCP_SERVER_NAME ?? "",
+        serverVersion: env.MCP_SERVER_VERSION ?? "",
+        runtimeProfile: env.SATORI_RUNTIME_PROFILE ?? "",
+        embeddingProvider: env.EMBEDDING_PROVIDER ?? "",
+        embeddingModel: env.EMBEDDING_MODEL ?? "",
+        embeddingDimension: env.EMBEDDING_OUTPUT_DIMENSION ?? "",
+        hybridMode: env.HYBRID_MODE ?? "",
+        embeddingBatchSize: env.EMBEDDING_BATCH_SIZE ?? "",
+        potionHelperPath: env.POTION_HELPER_PATH
+            ? canonicalizePath(env.POTION_HELPER_PATH)
+            : "",
+        potionModelPath: env.POTION_MODEL_PATH
+            ? canonicalizePath(env.POTION_MODEL_PATH)
+            : "",
+        potionRequestTimeoutMs: env.POTION_REQUEST_TIMEOUT_MS ?? "",
+        vectorStoreProvider: env.VECTOR_STORE_PROVIDER ?? "",
+        lanceDbPath: env.LANCEDB_PATH
+            ? canonicalizePath(env.LANCEDB_PATH)
+            : "",
+        watcherEnabled: env.MCP_ENABLE_WATCHER ?? "",
+        watcherDebounceMs: env.MCP_WATCH_DEBOUNCE_MS ?? "",
+        readFileMaxLines: env.READ_FILE_MAX_LINES ?? "",
+        customExtensions: env.CUSTOM_EXTENSIONS ?? "",
+        customIgnorePatterns: env.CUSTOM_IGNORE_PATTERNS ?? "",
+        navigationBackend: env.SATORI_NAVIGATION_BACKEND ?? "",
+        navigationDualRead: env.SATORI_NAVIGATION_DUAL_READ ?? "",
+        allTextMaxBytes: env.SATORI_ALL_TEXT_MAX_BYTES ?? "",
+        syncHashConcurrency: env.SATORI_SYNC_HASH_CONCURRENCY ?? "",
+        syncFullHashEveryN: env.SATORI_SYNC_FULL_HASH_EVERY_N ?? "",
+        sourceMeasurementLedger: env.SATORI_SOURCE_MEASUREMENT_LEDGER ?? "",
+        sourceMeasurementRoot: env.SATORI_SOURCE_MEASUREMENT_ROOT ?? "",
+    };
+    return Object.freeze({
+        ...payload,
+        hash: crypto.createHash("sha256").update(stableStringify(payload)).digest("hex"),
+    });
+}
+function assertOwnedDirectory(directory) {
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error(`Shared runtime directory '${directory}' is not an owned directory.`);
+    }
+    if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+        throw new Error(`Shared runtime directory '${directory}' belongs to another user.`);
+    }
+    const unsafeMode = stat.mode & 0o077;
+    if (unsafeMode !== 0) {
+        fs.chmodSync(directory, 0o700);
+    }
+}
+function ensureOwnedDirectory(directory) {
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    assertOwnedDirectory(directory);
+}
+function resolveSocketDirectory(env, stateRoot) {
+    const configured = env.XDG_RUNTIME_DIR;
+    if (configured && path.isAbsolute(configured) && fs.existsSync(configured)) {
+        assertOwnedDirectory(configured);
+        const directory = path.join(configured, "satori");
+        ensureOwnedDirectory(directory);
+        return directory;
+    }
+    const uid = typeof process.getuid === "function" ? process.getuid() : process.pid;
+    const base = path.join(os.tmpdir(), `satori-${uid}`);
+    ensureOwnedDirectory(base);
+    const directory = path.join(base, "runtime");
+    ensureOwnedDirectory(directory);
+    // The state root is intentionally not used for the socket. A managed home
+    // can exceed Linux's small sockaddr_un path limit.
+    void stateRoot;
+    return directory;
+}
+export function resolveSharedRuntimePaths(identity, env) {
+    const stateRoot = identity.stateRoot;
+    const metadataDirectory = path.join(stateRoot, "runtime-host", identity.hash);
+    ensureOwnedDirectory(metadataDirectory);
+    const socketDirectory = resolveSocketDirectory(env, stateRoot);
+    const socketPath = path.join(socketDirectory, `${identity.hash.slice(0, 24)}.sock`);
+    if (Buffer.byteLength(socketPath, "utf8") > 100) {
+        throw new Error(`Shared runtime socket path is too long: '${socketPath}'.`);
+    }
+    return Object.freeze({
+        stateRoot,
+        metadataDirectory,
+        metadataPath: path.join(metadataDirectory, "host.json"),
+        errorPath: path.join(metadataDirectory, "startup-error.json"),
+        lockPath: path.join(metadataDirectory, "startup.lock"),
+        socketDirectory,
+        socketPath,
+    });
+}
+//# sourceMappingURL=shared-runtime-identity.js.map

package/dist/server/shared-runtime-lifecycle.d.ts

@@ -0,0 +1,33 @@
+import type { SharedRuntimeIdentity, SharedRuntimePaths } from "./shared-runtime-identity.js";
+export type LinuxProcessIdentity = Readonly<{
+    pid: number;
+    bootId: string;
+    startTime: string;
+}>;
+export type SharedRuntimeHostMetadata = Readonly<{
+    formatVersion: 1;
+    protocolVersion: number;
+    hostPid: number;
+    bootId: string;
+    processStartTime: string;
+    mcpVersion: string;
+    sharedRuntimeIdentityHash: string;
+    installedRuntimeRoot: string;
+    ownershipToken: string;
+    socketPath: string;
+    socketDevice: number;
+    socketInode: number;
+    readyAt: string;
+}>;
+export type LifecycleLock = Readonly<{
+    ownershipToken: string;
+    release(): void;
+}>;
+export declare function readLinuxProcessIdentity(pid?: number): LinuxProcessIdentity | null;
+export declare function isLinuxProcessIdentityLive(identity: Pick<LinuxProcessIdentity, "pid" | "bootId" | "startTime">): boolean;
+export declare function readHostMetadata(metadataPath: string): SharedRuntimeHostMetadata | null;
+export declare function writeHostMetadataAtomic(metadataPath: string, metadata: SharedRuntimeHostMetadata): void;
+export declare function acquireLifecycleLock(lockPath: string, timeoutMs?: number): Promise<LifecycleLock>;
+export declare function metadataMatchesIdentity(metadata: SharedRuntimeHostMetadata, identity: SharedRuntimeIdentity): boolean;
+export declare function removeOwnedLifecycleState(paths: SharedRuntimePaths, expected: Pick<SharedRuntimeHostMetadata, "hostPid" | "bootId" | "processStartTime" | "ownershipToken" | "sharedRuntimeIdentityHash" | "socketPath" | "socketDevice" | "socketInode">): void;
+//# sourceMappingURL=shared-runtime-lifecycle.d.ts.map