@caryhu/codemine-forge 0.0.1-alpha.0 → 0.0.1-alpha.1

package/dist/package-resolution/resolver.js

@@ -1,17 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPackageCacheKey = exports.createPackageResolver = exports.DefaultPackageResolver = void 0;
+const virtual_file_system_1 = require("../virtual-file-system");
+const telemetry_1 = require("../telemetry");
 const manifest_1 = require("./manifest");
 const diagnostics_1 = require("./diagnostics");
 const errors_1 = require("./errors");
 const types_1 = require("./types");
 const DEFAULT_RESOLUTION_MODE = "bundle-alias";
+const DEFAULT_CACHE_MODE = "prefer-cache";
 class DefaultPackageResolver {
     constructor(options) {
         this.options = options;
         this.capability = types_1.PACKAGE_RESOLUTION_CAPABILITY;
         this.sources = options.sources ?? [];
         this.resolutionMode = options.resolutionMode ?? DEFAULT_RESOLUTION_MODE;
+        this.cacheMode = options.cacheMode ?? DEFAULT_CACHE_MODE;
+        this.telemetry = options.telemetry;
         this.manifestPath = options.manifestPath ?? manifest_1.DEFAULT_FORGE_MANIFEST_PATH;
         this.now = options.now ?? (() => new Date().toISOString());
     }
@@ -19,38 +24,86 @@ class DefaultPackageResolver {
         return (0, manifest_1.readPackageManifest)(this.options.fileSystem, manifestPath);
     }
     async resolve(options = {}) {
-        const manifest = await this.readManifest(options.manifestPath ?? this.manifestPath);
-        const requests = (0, manifest_1.collectDependencyRequests)(manifest);
+        const telemetryStart = (0, telemetry_1.startForgeTelemetryTiming)(this.now());
+        const telemetry = options.telemetry ?? this.telemetry;
         const sources = options.sources ?? this.sources;
         const resolutionMode = options.resolutionMode ?? this.resolutionMode;
-        const packages = [];
-        for (const request of requests) {
-            packages.push(await this.resolveRequest(request, sources));
-        }
-        packages.sort((left, right) => left.name.localeCompare(right.name));
-        const lock = createLockMetadata(packages, resolutionMode);
-        const resultBase = {
-            manifest,
-            requests,
-            packages,
-            lock,
-            warnings: [],
-        };
-        if (resolutionMode === "import-map") {
-            return {
-                ...resultBase,
-                importMap: createImportMap(packages),
+        const cacheMode = options.cacheMode ?? this.cacheMode;
+        let requests;
+        try {
+            const manifest = await this.readManifest(options.manifestPath ?? this.manifestPath);
+            requests = (0, manifest_1.collectDependencyRequests)(manifest);
+            const packages = [];
+            const warnings = [];
+            for (const request of requests) {
+                try {
+                    const result = await this.resolveRequest(request, sources, cacheMode);
+                    packages.push(result.packageRecord);
+                    warnings.push(...result.warnings);
+                }
+                catch (error) {
+                    if (error instanceof errors_1.ForgePackageResolutionError &&
+                        (warnings.length > 0 || error.warnings.length > 0)) {
+                        throw new errors_1.ForgePackageResolutionError(error.diagnostic, [
+                            ...warnings,
+                            ...error.warnings,
+                        ]);
+                    }
+                    throw error;
+                }
+            }
+            packages.sort((left, right) => left.name.localeCompare(right.name));
+            const lock = createLockMetadata(packages, resolutionMode);
+            const resultBase = {
+                manifest,
+                requests,
+                packages,
+                lock,
+                warnings,
             };
+            const result = resolutionMode === "import-map"
+                ? {
+                    ...resultBase,
+                    importMap: createImportMap(packages),
+                }
+                : {
+                    ...resultBase,
+                    aliases: createBundleAliases(packages),
+                };
+            this.emitTelemetry(telemetry, telemetryStart, {
+                cacheMode,
+                dependencyCount: requests.length,
+                diagnostics: warnings,
+                outcome: "success",
+                packageCount: packages.length,
+                resolutionMode,
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ForgePackageResolutionError) {
+                this.emitTelemetry(telemetry, telemetryStart, {
+                    cacheMode,
+                    dependencyCount: requests?.length,
+                    diagnostics: [error.diagnostic, ...error.warnings],
+                    outcome: "failure",
+                    packageCount: undefined,
+                    resolutionMode,
+                });
+            }
+            throw error;
         }
-        return {
-            ...resultBase,
-            aliases: createBundleAliases(packages),
-        };
     }
-    async resolveRequest(request, sources) {
+    async resolveRequest(request, sources, cacheMode) {
         const cachedPackage = await this.readCachedPackage(request);
         if (cachedPackage !== undefined) {
-            return cachedPackage;
+            return {
+                packageRecord: cachedPackage,
+                warnings: [],
+            };
+        }
+        if (cacheMode === "cache-only") {
+            throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createOfflineCacheMissDiagnostic)(request.name, request.requestedRange));
         }
         for (const source of sources) {
             const packageRecord = await source.resolvePackage(request);
@@ -58,8 +111,11 @@ class DefaultPackageResolver {
                 continue;
             }
             const normalizedRecord = normalizePackageRecord(request, source.id, packageRecord);
-            await this.writeCachedPackage(request, normalizedRecord);
-            return normalizedRecord;
+            const warnings = await this.writeCachedPackage(request, normalizedRecord);
+            return {
+                packageRecord: normalizedRecord,
+                warnings,
+            };
         }
         throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createUnresolvedPackageDiagnostic)(request.name, request.requestedRange));
     }
@@ -78,8 +134,9 @@ class DefaultPackageResolver {
     }
     async writeCachedPackage(request, packageRecord) {
         if (this.options.storage === undefined) {
-            return;
+            return [];
         }
+        const warnings = [];
         const records = [
             createCacheRecord(createPackageCacheKey(request.name, request.requestedRange), packageRecord, this.now()),
         ];
@@ -87,8 +144,35 @@ class DefaultPackageResolver {
             records.push(createCacheRecord(createPackageCacheKey(request.name, packageRecord.version), packageRecord, this.now()));
         }
         for (const record of records) {
-            await this.options.storage.putPackageCacheRecord(record);
+            try {
+                await this.options.storage.putPackageCacheRecord(record);
+            }
+            catch (error) {
+                if (isLimitExceededError(error)) {
+                    warnings.push(toWarningDiagnostic(error.diagnostic));
+                    continue;
+                }
+                throw error;
+            }
         }
+        return warnings;
+    }
+    emitTelemetry(telemetry, telemetryStart, input) {
+        const diagnosticSummaries = (0, telemetry_1.summarizeForgeTelemetryDiagnostics)(input.diagnostics);
+        const errorDiagnostic = input.diagnostics.find((diagnostic) => diagnostic.severity === "error");
+        (0, telemetry_1.emitForgeTelemetry)(telemetry, {
+            operation: "package-resolution",
+            outcome: input.outcome,
+            ...(0, telemetry_1.completeForgeTelemetryTiming)(telemetryStart, this.now()),
+            cacheMode: input.cacheMode,
+            resolutionMode: input.resolutionMode,
+            dependencyCount: input.dependencyCount,
+            packageCount: input.packageCount,
+            diagnostics: diagnosticSummaries,
+            unsupportedPackageReason: errorDiagnostic === undefined
+                ? undefined
+                : (0, telemetry_1.createForgeUnsupportedPackageReason)(errorDiagnostic),
+        });
     }
 }
 exports.DefaultPackageResolver = DefaultPackageResolver;
@@ -170,3 +254,13 @@ function isForgePackageRecord(value) {
         typeof record.files === "object" &&
         record.files !== null);
 }
+function isLimitExceededError(error) {
+    return (error instanceof virtual_file_system_1.ForgeFileSystemError &&
+        error.diagnostic.code === "limit_exceeded");
+}
+function toWarningDiagnostic(diagnostic) {
+    return {
+        ...diagnostic,
+        severity: "warning",
+    };
+}

package/dist/package-resolution/types.d.ts

@@ -1,8 +1,10 @@
 import type { ForgeDiagnostic, ForgeVirtualFileSystemStorage } from "../virtual-file-system";
 import type { ForgeVirtualFileSystem } from "../virtual-file-system";
+import type { ForgeTelemetryReporter } from "../telemetry";
 export declare const PACKAGE_RESOLUTION_CAPABILITY: "package-resolution";
 export type ForgePackageResolutionMode = "import-map" | "bundle-alias";
-export type ForgePackageResolutionDiagnosticCode = "invalid_dependency" | "invalid_manifest" | "unresolved_package" | "unsupported_range";
+export type ForgePackageCacheMode = "prefer-cache" | "cache-only";
+export type ForgePackageResolutionDiagnosticCode = "invalid_dependency" | "invalid_manifest" | "offline_cache_miss" | "unresolved_package" | "unsupported_range";
 export interface ForgePackageResolutionDiagnostic {
     readonly code: ForgePackageResolutionDiagnosticCode;
     readonly severity: "error";
@@ -74,12 +76,16 @@ export interface ForgePackageResolverOptions {
     readonly storage?: ForgeVirtualFileSystemStorage;
     readonly sources?: readonly ForgePackageSource[];
     readonly resolutionMode?: ForgePackageResolutionMode;
+    readonly cacheMode?: ForgePackageCacheMode;
+    readonly telemetry?: ForgeTelemetryReporter;
     readonly manifestPath?: string;
     readonly now?: () => string;
 }
 export interface ForgeResolvePackagesOptions {
     readonly sources?: readonly ForgePackageSource[];
     readonly resolutionMode?: ForgePackageResolutionMode;
+    readonly cacheMode?: ForgePackageCacheMode;
+    readonly telemetry?: ForgeTelemetryReporter;
     readonly manifestPath?: string;
 }
 export interface ForgePackageResolutionResult {

package/dist/telemetry/index.d.ts

@@ -0,0 +1,68 @@
+export declare const TELEMETRY_CAPABILITY: "telemetry";
+export type ForgeTelemetryOperation = "build" | "package-resolution";
+export type ForgeTelemetryOutcome = "failure" | "success";
+export interface ForgeTelemetryTiming {
+    readonly startedAt: string;
+    readonly endedAt: string;
+    readonly durationMs: number;
+}
+export interface ForgeTelemetryTimingStart {
+    readonly startedAt: string;
+    readonly startedMs: number;
+}
+export interface ForgeTelemetryDiagnosticSummary {
+    readonly code: string;
+    readonly severity: "error" | "info" | "warning";
+    readonly message: string;
+    readonly path?: string;
+    readonly dependencyName?: string;
+    readonly requestedRange?: string;
+    readonly importer?: string;
+    readonly importSpecifier?: string;
+    readonly limitName?: string;
+}
+export interface ForgeUnsupportedPackageReason {
+    readonly code: string;
+    readonly message: string;
+    readonly dependencyName?: string;
+    readonly requestedRange?: string;
+}
+export interface ForgePackageResolutionTelemetryEvent extends ForgeTelemetryTiming {
+    readonly operation: "package-resolution";
+    readonly outcome: ForgeTelemetryOutcome;
+    readonly cacheMode: string;
+    readonly resolutionMode: string;
+    readonly dependencyCount?: number;
+    readonly packageCount?: number;
+    readonly diagnostics: readonly ForgeTelemetryDiagnosticSummary[];
+    readonly unsupportedPackageReason?: ForgeUnsupportedPackageReason;
+}
+export interface ForgeBuildTelemetryEvent extends ForgeTelemetryTiming {
+    readonly operation: "build";
+    readonly outcome: ForgeTelemetryOutcome;
+    readonly mode: string;
+    readonly entry?: string;
+    readonly outputFileCount: number;
+    readonly packageCount?: number;
+    readonly diagnostics: readonly ForgeTelemetryDiagnosticSummary[];
+}
+export type ForgeTelemetryEvent = ForgeBuildTelemetryEvent | ForgePackageResolutionTelemetryEvent;
+export type ForgeTelemetryReporter = (event: ForgeTelemetryEvent) => void;
+export interface ForgeTelemetryDiagnosticLike {
+    readonly code: string;
+    readonly severity: "error" | "info" | "warning";
+    readonly message: string;
+    readonly path?: string;
+    readonly dependencyName?: string;
+    readonly requestedRange?: string;
+    readonly importer?: string;
+    readonly importSpecifier?: string;
+    readonly limit?: {
+        readonly name?: string;
+    };
+}
+export declare function startForgeTelemetryTiming(startedAt: string): ForgeTelemetryTimingStart;
+export declare function completeForgeTelemetryTiming(start: ForgeTelemetryTimingStart, endedAt: string): ForgeTelemetryTiming;
+export declare function summarizeForgeTelemetryDiagnostics(diagnostics: readonly ForgeTelemetryDiagnosticLike[]): readonly ForgeTelemetryDiagnosticSummary[];
+export declare function createForgeUnsupportedPackageReason(diagnostic: ForgeTelemetryDiagnosticLike): ForgeUnsupportedPackageReason | undefined;
+export declare function emitForgeTelemetry(reporter: ForgeTelemetryReporter | undefined, event: ForgeTelemetryEvent): void;

package/dist/telemetry/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitForgeTelemetry = exports.createForgeUnsupportedPackageReason = exports.summarizeForgeTelemetryDiagnostics = exports.completeForgeTelemetryTiming = exports.startForgeTelemetryTiming = exports.TELEMETRY_CAPABILITY = void 0;
+exports.TELEMETRY_CAPABILITY = "telemetry";
+function startForgeTelemetryTiming(startedAt) {
+    return {
+        startedAt,
+        startedMs: Date.now(),
+    };
+}
+exports.startForgeTelemetryTiming = startForgeTelemetryTiming;
+function completeForgeTelemetryTiming(start, endedAt) {
+    return {
+        startedAt: start.startedAt,
+        endedAt,
+        durationMs: Math.max(0, Date.now() - start.startedMs),
+    };
+}
+exports.completeForgeTelemetryTiming = completeForgeTelemetryTiming;
+function summarizeForgeTelemetryDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => ({
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        message: diagnostic.message,
+        path: diagnostic.path,
+        dependencyName: diagnostic.dependencyName,
+        requestedRange: diagnostic.requestedRange,
+        importer: diagnostic.importer,
+        importSpecifier: diagnostic.importSpecifier,
+        limitName: diagnostic.limit?.name,
+    }));
+}
+exports.summarizeForgeTelemetryDiagnostics = summarizeForgeTelemetryDiagnostics;
+function createForgeUnsupportedPackageReason(diagnostic) {
+    if (!isUnsupportedPackageDiagnosticCode(diagnostic.code)) {
+        return undefined;
+    }
+    return {
+        code: diagnostic.code,
+        message: diagnostic.message,
+        dependencyName: diagnostic.dependencyName,
+        requestedRange: diagnostic.requestedRange,
+    };
+}
+exports.createForgeUnsupportedPackageReason = createForgeUnsupportedPackageReason;
+function emitForgeTelemetry(reporter, event) {
+    if (reporter === undefined) {
+        return;
+    }
+    try {
+        reporter(event);
+    }
+    catch {
+        // Telemetry is observational and must not alter runtime behavior.
+    }
+}
+exports.emitForgeTelemetry = emitForgeTelemetry;
+function isUnsupportedPackageDiagnosticCode(code) {
+    return [
+        "invalid_dependency",
+        "offline_cache_miss",
+        "unresolved_package",
+        "unsupported_range",
+    ].includes(code);
+}

package/dist/terminal-commands/npm-build.js

@@ -20,7 +20,9 @@ class NpmRunBuildCommandHandler {
                 diagnostics: [],
             };
         }
-        const buildResult = await context.buildPipeline.build();
+        const buildResult = await context.buildPipeline.build({
+            signal: context.signal,
+        });
         if (!buildResult.success) {
             const firstDiagnostic = buildResult.diagnostics[0];
             return {

package/dist/terminal-commands/npm-dev.js

@@ -20,7 +20,9 @@ class NpmRunDevCommandHandler {
                 diagnostics: [],
             };
         }
-        const startResult = await context.devServerPreview.start();
+        const startResult = await context.devServerPreview.start({
+            signal: context.signal,
+        });
         if (!startResult.success) {
             const firstDiagnostic = startResult.diagnostics[0];
             return {

package/dist/terminal-commands/npm-install.js

@@ -25,8 +25,8 @@ class NpmInstallCommandHandler {
             return {
                 command: context.command,
                 exitCode: 0,
-                output,
-                diagnostics: [],
+                output: [...output, ...warningOutput(packageResolution.warnings)],
+                diagnostics: packageResolution.warnings,
                 packageResolution,
             };
         }
@@ -54,3 +54,8 @@ function stdout(text) {
 function stderr(text) {
     return { kind: "stderr", text };
 }
+function warningOutput(diagnostics) {
+    return diagnostics
+        .filter((diagnostic) => diagnostic.severity === "warning")
+        .map((diagnostic) => stderr(`Forge warning: ${diagnostic.message}`));
+}

package/dist/terminal-commands/terminal.d.ts

@@ -7,6 +7,7 @@ export declare class DefaultForgeTerminal implements ForgeTerminal {
     constructor(options: ForgeTerminalOptions);
     execute(commandText: string, executeOptions?: {
         readonly cwd?: string;
+        readonly signal?: AbortSignal;
     }): Promise<ForgeCommandResult>;
 }
 export declare function createForgeTerminal(options: ForgeTerminalOptions): ForgeTerminal;

package/dist/terminal-commands/terminal.js

@@ -42,6 +42,7 @@ class DefaultForgeTerminal {
             buildPipeline: this.options.buildPipeline,
             devServerPreview: this.options.devServerPreview,
             packageResolver: this.options.packageResolver,
+            signal: executeOptions.signal,
         });
     }
 }

package/dist/terminal-commands/types.d.ts

@@ -35,6 +35,7 @@ export interface ForgeCommandContext {
     readonly buildPipeline?: ForgeBuildPipeline;
     readonly devServerPreview?: ForgeDevServerPreview;
     readonly packageResolver: ForgePackageResolver;
+    readonly signal?: AbortSignal;
 }
 export interface ForgeCommandHandler {
     readonly name: string;
@@ -44,6 +45,7 @@ export interface ForgeCommandHandler {
 }
 export interface ForgeTerminalExecuteOptions {
     readonly cwd?: string;
+    readonly signal?: AbortSignal;
 }
 export interface ForgeTerminalOptions {
     readonly buildPipeline?: ForgeBuildPipeline;

package/dist/virtual-file-system/diagnostics.d.ts

@@ -8,6 +8,7 @@ export interface ForgeDiagnosticInput {
 }
 export declare function createForgeDiagnostic(input: ForgeDiagnosticInput): ForgeDiagnostic;
 export declare function createInvalidPathDiagnostic(path: string, message?: string): ForgeDiagnostic;
+export declare function createInvalidSnapshotDiagnostic(message?: string, cause?: unknown): ForgeDiagnostic;
 export declare function createPathTraversalDiagnostic(path: string): ForgeDiagnostic;
 export declare function createNotFoundDiagnostic(path: string): ForgeDiagnostic;
 export declare function createMissingParentDiagnostic(path: string): ForgeDiagnostic;

package/dist/virtual-file-system/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNotImplementedDiagnostic = exports.createMissingParentDiagnostic = exports.createNotFoundDiagnostic = exports.createPathTraversalDiagnostic = exports.createInvalidPathDiagnostic = exports.createForgeDiagnostic = void 0;
+exports.createNotImplementedDiagnostic = exports.createMissingParentDiagnostic = exports.createNotFoundDiagnostic = exports.createPathTraversalDiagnostic = exports.createInvalidSnapshotDiagnostic = exports.createInvalidPathDiagnostic = exports.createForgeDiagnostic = void 0;
 function createForgeDiagnostic(input) {
     return {
         code: input.code,
@@ -20,6 +20,14 @@ function createInvalidPathDiagnostic(path, message = "Path is invalid.") {
     });
 }
 exports.createInvalidPathDiagnostic = createInvalidPathDiagnostic;
+function createInvalidSnapshotDiagnostic(message = "Workspace snapshot payload is invalid.", cause) {
+    return createForgeDiagnostic({
+        code: "invalid_snapshot",
+        message,
+        cause,
+    });
+}
+exports.createInvalidSnapshotDiagnostic = createInvalidSnapshotDiagnostic;
 function createPathTraversalDiagnostic(path) {
     return createForgeDiagnostic({
         code: "path_traversal",

package/dist/virtual-file-system/index.d.ts

@@ -1,11 +1,13 @@
 import type { ForgeDeleteOptions, ForgeDirEntry, ForgeFileStat, ForgeFileWatchListener, ForgeMkdirOptions, ForgeOpenVirtualFileSystemOptions, ForgeRestoreOptions, ForgeSnapshot, ForgeSnapshotOptions, ForgeUnsubscribe, ForgeVirtualFileSystemOptions, ForgeWriteFileOptions } from "./types";
 export { DEFAULT_FORGE_VFS_LIMITS, createLimitExceededDiagnostic, resolveForgeVirtualFileSystemLimits, } from "./limits";
-export { createForgeDiagnostic, createInvalidPathDiagnostic, createMissingParentDiagnostic, createNotFoundDiagnostic, createNotImplementedDiagnostic, createPathTraversalDiagnostic, type ForgeDiagnosticInput, } from "./diagnostics";
+export { createForgeDiagnostic, createInvalidSnapshotDiagnostic, createInvalidPathDiagnostic, createMissingParentDiagnostic, createNotFoundDiagnostic, createNotImplementedDiagnostic, createPathTraversalDiagnostic, type ForgeDiagnosticInput, } from "./diagnostics";
 export { normalizeForgePath, type ForgePathNormalizationResult, } from "./path";
 export { ForgeFileSystemError } from "./errors";
 export { InMemoryVirtualFileSystem } from "./memory";
 export { createIndexedDbForgeStorage, FORGE_INDEXED_DB_NAME, FORGE_INDEXED_DB_STORES, FORGE_INDEXED_DB_VERSION, IndexedDbForgeStorage, type IndexedDbForgeStorageOptions, } from "./storage";
-export type { ForgeBuildCacheRecord, ForgeDeleteOptions, ForgeDiagnostic, ForgeDiagnosticCode, ForgeDiagnosticSeverity, ForgeDirEntry, ForgeFileCreatedEvent, ForgeFileDeletedEvent, ForgeFileEvent, ForgeFileKind, ForgeFileRecord, ForgeFileRenamedEvent, ForgeFileSource, ForgeFileStat, ForgeFileUpdatedEvent, ForgeFileWatchListener, ForgeLimitDiagnostic, ForgeMkdirOptions, ForgeOpenVirtualFileSystemOptions, ForgePackageCacheRecord, ForgePersistedWorkspace, ForgeVirtualFileSystemLimits, ResolvedForgeVirtualFileSystemLimits, ForgeRestoreOptions, ForgeSnapshot, ForgeSnapshotOptions, ForgeUnsubscribe, ForgeVirtualFileSystemOptions, ForgeVirtualFileSystemStorage, ForgeWorkspace, ForgeWorkspaceMetadata, ForgeWriteFileOptions, } from "./types";
+export { exportWorkspaceSnapshot, importWorkspaceSnapshot, } from "./snapshot-serialization";
+export { FORGE_WORKSPACE_SNAPSHOT_EXPORT_SCHEMA_VERSION } from "./types";
+export type { ForgeBuildCacheRecord, ForgeDeleteOptions, ForgeDiagnostic, ForgeDiagnosticCode, ForgeDiagnosticSeverity, ForgeDirEntry, ForgeFileCreatedEvent, ForgeFileDeletedEvent, ForgeFileEvent, ForgeFileKind, ForgeFileRecord, ForgeFileRenamedEvent, ForgeFileSource, ForgeFileStat, ForgeFileUpdatedEvent, ForgeFileWatchListener, ForgeLimitDiagnostic, ForgeMkdirOptions, ForgeOpenVirtualFileSystemOptions, ForgePackageCacheRecord, ForgePersistedWorkspace, ForgeSerializedFileRecord, ForgeSerializedWorkspaceSnapshot, ForgeSerializedWorkspaceSnapshotPayload, ForgeVirtualFileSystemLimits, ResolvedForgeVirtualFileSystemLimits, ForgeRestoreOptions, ForgeSnapshot, ForgeSnapshotOptions, ForgeUnsubscribe, ForgeVirtualFileSystemOptions, ForgeVirtualFileSystemStorage, ForgeWorkspace, ForgeWorkspaceMetadata, ForgeWorkspaceSnapshotExportOptions, ForgeWriteFileOptions, } from "./types";
 export declare const VIRTUAL_FILE_SYSTEM_CAPABILITY: "virtual-file-system";
 export interface ForgeVirtualFileSystem {
     readonly capability: typeof VIRTUAL_FILE_SYSTEM_CAPABILITY;

package/dist/virtual-file-system/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openVirtualFileSystem = exports.createVirtualFileSystem = exports.VIRTUAL_FILE_SYSTEM_CAPABILITY = exports.IndexedDbForgeStorage = exports.FORGE_INDEXED_DB_VERSION = exports.FORGE_INDEXED_DB_STORES = exports.FORGE_INDEXED_DB_NAME = exports.createIndexedDbForgeStorage = exports.InMemoryVirtualFileSystem = exports.ForgeFileSystemError = exports.normalizeForgePath = exports.createPathTraversalDiagnostic = exports.createNotImplementedDiagnostic = exports.createNotFoundDiagnostic = exports.createMissingParentDiagnostic = exports.createInvalidPathDiagnostic = exports.createForgeDiagnostic = exports.resolveForgeVirtualFileSystemLimits = exports.createLimitExceededDiagnostic = exports.DEFAULT_FORGE_VFS_LIMITS = void 0;
+exports.openVirtualFileSystem = exports.createVirtualFileSystem = exports.VIRTUAL_FILE_SYSTEM_CAPABILITY = exports.FORGE_WORKSPACE_SNAPSHOT_EXPORT_SCHEMA_VERSION = exports.importWorkspaceSnapshot = exports.exportWorkspaceSnapshot = exports.IndexedDbForgeStorage = exports.FORGE_INDEXED_DB_VERSION = exports.FORGE_INDEXED_DB_STORES = exports.FORGE_INDEXED_DB_NAME = exports.createIndexedDbForgeStorage = exports.InMemoryVirtualFileSystem = exports.ForgeFileSystemError = exports.normalizeForgePath = exports.createPathTraversalDiagnostic = exports.createNotImplementedDiagnostic = exports.createNotFoundDiagnostic = exports.createMissingParentDiagnostic = exports.createInvalidPathDiagnostic = exports.createInvalidSnapshotDiagnostic = exports.createForgeDiagnostic = exports.resolveForgeVirtualFileSystemLimits = exports.createLimitExceededDiagnostic = exports.DEFAULT_FORGE_VFS_LIMITS = void 0;
 const memory_1 = require("./memory");
 const storage_1 = require("./storage");
 var limits_1 = require("./limits");
@@ -9,6 +9,7 @@ Object.defineProperty(exports, "createLimitExceededDiagnostic", { enumerable: tr
 Object.defineProperty(exports, "resolveForgeVirtualFileSystemLimits", { enumerable: true, get: function () { return limits_1.resolveForgeVirtualFileSystemLimits; } });
 var diagnostics_1 = require("./diagnostics");
 Object.defineProperty(exports, "createForgeDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createForgeDiagnostic; } });
+Object.defineProperty(exports, "createInvalidSnapshotDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidSnapshotDiagnostic; } });
 Object.defineProperty(exports, "createInvalidPathDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidPathDiagnostic; } });
 Object.defineProperty(exports, "createMissingParentDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingParentDiagnostic; } });
 Object.defineProperty(exports, "createNotFoundDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createNotFoundDiagnostic; } });
@@ -26,6 +27,11 @@ Object.defineProperty(exports, "FORGE_INDEXED_DB_NAME", { enumerable: true, get:
 Object.defineProperty(exports, "FORGE_INDEXED_DB_STORES", { enumerable: true, get: function () { return storage_2.FORGE_INDEXED_DB_STORES; } });
 Object.defineProperty(exports, "FORGE_INDEXED_DB_VERSION", { enumerable: true, get: function () { return storage_2.FORGE_INDEXED_DB_VERSION; } });
 Object.defineProperty(exports, "IndexedDbForgeStorage", { enumerable: true, get: function () { return storage_2.IndexedDbForgeStorage; } });
+var snapshot_serialization_1 = require("./snapshot-serialization");
+Object.defineProperty(exports, "exportWorkspaceSnapshot", { enumerable: true, get: function () { return snapshot_serialization_1.exportWorkspaceSnapshot; } });
+Object.defineProperty(exports, "importWorkspaceSnapshot", { enumerable: true, get: function () { return snapshot_serialization_1.importWorkspaceSnapshot; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "FORGE_WORKSPACE_SNAPSHOT_EXPORT_SCHEMA_VERSION", { enumerable: true, get: function () { return types_1.FORGE_WORKSPACE_SNAPSHOT_EXPORT_SCHEMA_VERSION; } });
 exports.VIRTUAL_FILE_SYSTEM_CAPABILITY = "virtual-file-system";
 function createVirtualFileSystem(options) {
     return new memory_1.InMemoryVirtualFileSystem(options);

package/dist/virtual-file-system/snapshot-serialization.d.ts

@@ -0,0 +1,3 @@
+import type { ForgeSerializedWorkspaceSnapshotPayload, ForgeSnapshot, ForgeWorkspaceSnapshotExportOptions } from "./types";
+export declare function exportWorkspaceSnapshot(snapshot: ForgeSnapshot, options?: ForgeWorkspaceSnapshotExportOptions): string;
+export declare function importWorkspaceSnapshot(payload: string | ForgeSerializedWorkspaceSnapshotPayload): ForgeSnapshot;