@caryhu/codemine-forge 0.0.1-alpha.3 → 0.0.1-alpha.4

package/dist/package-resolution/cdn-source.js

@@ -40,7 +40,11 @@ exports.createCdnPackageSource = createCdnPackageSource;
 function createDefaultMetadataUrl(request, baseUrl) {
     const trimmedBase = baseUrl.replace(/\/+$/, "");
     const packageKey = `${encodeURIComponent(request.name)}@${encodeURIComponent(request.requestedRange)}`;
-    return `${trimmedBase}/${packageKey}.json`;
+    const peerDependencyPins = formatPeerDependencyPins(request.peerDependencyPins);
+    const query = peerDependencyPins.length === 0
+        ? ""
+        : `?deps=${encodeURIComponent(peerDependencyPins.join(","))}`;
+    return `${trimmedBase}/${packageKey}.json${query}`;
 }
 function normalizeCdnPackageRecord(metadata, request, sourceId) {
     if (!isPlainObject(metadata)) {
@@ -64,6 +68,9 @@ function normalizeCdnPackageRecord(metadata, request, sourceId) {
         dependencies: stringRecordField(metadata, "dependencies") ?? {},
         files: packageFilesField(metadata, "files") ?? {},
         integrity: stringField(metadata, "integrity"),
+        peerDependencies: stringRecordField(metadata, "peerDependencies") ?? {},
+        peerDependencyPins: stringRecordField(metadata, "peerDependencyPins") ??
+            request.peerDependencyPins,
     };
 }
 function selectPackageEntry(metadata) {
@@ -162,3 +169,8 @@ function isPlainObject(value) {
         value !== null &&
         !Array.isArray(value));
 }
+function formatPeerDependencyPins(peerDependencyPins) {
+    return Object.entries(peerDependencyPins ?? {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, version]) => `${name}@${version}`);
+}

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

@@ -13,4 +13,7 @@ export declare function createInvalidDependencyDiagnostic(dependencyName: string
 export declare function createUnsupportedRangeDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
 export declare function createOfflineCacheMissDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
 export declare function createUnresolvedPackageDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
+export declare function createAngularPeerDependencyUnpinnedDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
+export declare function createAngularSingletonDuplicateDiagnostic(dependencyName: string, requestedRange: string, message?: string): ForgePackageResolutionDiagnostic;
+export declare function createAngularSingletonVersionConflictDiagnostic(dependencyName: string, requestedRange: string): ForgePackageResolutionDiagnostic;
 export {};

package/dist/package-resolution/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUnresolvedPackageDiagnostic = exports.createOfflineCacheMissDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createInvalidDependencyDiagnostic = exports.createInvalidManifestDiagnostic = exports.createPackageResolutionDiagnostic = void 0;
+exports.createAngularSingletonVersionConflictDiagnostic = exports.createAngularSingletonDuplicateDiagnostic = exports.createAngularPeerDependencyUnpinnedDiagnostic = exports.createUnresolvedPackageDiagnostic = exports.createOfflineCacheMissDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createInvalidDependencyDiagnostic = exports.createInvalidManifestDiagnostic = exports.createPackageResolutionDiagnostic = void 0;
 function createPackageResolutionDiagnostic(input) {
     return {
         code: input.code,
@@ -58,3 +58,30 @@ function createUnresolvedPackageDiagnostic(dependencyName, requestedRange) {
     });
 }
 exports.createUnresolvedPackageDiagnostic = createUnresolvedPackageDiagnostic;
+function createAngularPeerDependencyUnpinnedDiagnostic(dependencyName, requestedRange) {
+    return createPackageResolutionDiagnostic({
+        code: "angular_peer_dependency_unpinned",
+        message: "Angular peer dependency could not be pinned to a workspace Angular version.",
+        dependencyName,
+        requestedRange,
+    });
+}
+exports.createAngularPeerDependencyUnpinnedDiagnostic = createAngularPeerDependencyUnpinnedDiagnostic;
+function createAngularSingletonDuplicateDiagnostic(dependencyName, requestedRange, message = "Angular singleton package resolved to a dependency-wrapper URL.") {
+    return createPackageResolutionDiagnostic({
+        code: "angular_singleton_duplicate",
+        message,
+        dependencyName,
+        requestedRange,
+    });
+}
+exports.createAngularSingletonDuplicateDiagnostic = createAngularSingletonDuplicateDiagnostic;
+function createAngularSingletonVersionConflictDiagnostic(dependencyName, requestedRange) {
+    return createPackageResolutionDiagnostic({
+        code: "angular_singleton_version_conflict",
+        message: "Angular singleton package resolved to a version that conflicts with the workspace request.",
+        dependencyName,
+        requestedRange,
+    });
+}
+exports.createAngularSingletonVersionConflictDiagnostic = createAngularSingletonVersionConflictDiagnostic;

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

@@ -1,6 +1,7 @@
 export { createCdnPackageSource, type ForgeCdnPackageFetch, type ForgeCdnPackageMetadataUrlFactory, type ForgeCdnPackageSourceOptions, } from "./cdn-source";
-export { createInvalidDependencyDiagnostic, createInvalidManifestDiagnostic, createOfflineCacheMissDiagnostic, createPackageResolutionDiagnostic, createUnsupportedRangeDiagnostic, createUnresolvedPackageDiagnostic, } from "./diagnostics";
+export { createAngularPeerDependencyUnpinnedDiagnostic, createAngularSingletonDuplicateDiagnostic, createAngularSingletonVersionConflictDiagnostic, createInvalidDependencyDiagnostic, createInvalidManifestDiagnostic, createOfflineCacheMissDiagnostic, createPackageResolutionDiagnostic, createUnsupportedRangeDiagnostic, createUnresolvedPackageDiagnostic, } from "./diagnostics";
 export { ForgePackageResolutionError } from "./errors";
+export type { ForgeAngularCompatibilityOptions, ForgeFrameworkCompatibilityOptions, } from "../framework-compatibility";
 export { collectDependencyRequests, DEFAULT_FORGE_MANIFEST_PATH, readPackageManifest, } from "./manifest";
 export { createPackageCacheKey, createPackageResolver, DefaultPackageResolver, } from "./resolver";
 export { PACKAGE_RESOLUTION_CAPABILITY, type ForgeBundleAliases, type ForgeDependencyKind, type ForgeDependencyRequest, type ForgeImportMap, type ForgePackageCacheMode, type ForgePackageDiagnostic, type ForgePackageFile, type ForgePackageLockMetadata, type ForgePackageLockPackage, type ForgePackageManifest, type ForgePackageRecord, type ForgePackageResolutionDiagnostic, type ForgePackageResolutionDiagnosticCode, type ForgePackageResolutionMode, type ForgePackageResolutionResult, type ForgePackageResolver, type ForgePackageResolverOptions, type ForgePackageSource, type ForgeResolvePackagesOptions, } from "./types";

package/dist/package-resolution/index.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PACKAGE_RESOLUTION_CAPABILITY = exports.DefaultPackageResolver = exports.createPackageResolver = exports.createPackageCacheKey = exports.readPackageManifest = exports.DEFAULT_FORGE_MANIFEST_PATH = exports.collectDependencyRequests = exports.ForgePackageResolutionError = exports.createUnresolvedPackageDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createPackageResolutionDiagnostic = exports.createOfflineCacheMissDiagnostic = exports.createInvalidManifestDiagnostic = exports.createInvalidDependencyDiagnostic = exports.createCdnPackageSource = void 0;
+exports.PACKAGE_RESOLUTION_CAPABILITY = exports.DefaultPackageResolver = exports.createPackageResolver = exports.createPackageCacheKey = exports.readPackageManifest = exports.DEFAULT_FORGE_MANIFEST_PATH = exports.collectDependencyRequests = exports.ForgePackageResolutionError = exports.createUnresolvedPackageDiagnostic = exports.createUnsupportedRangeDiagnostic = exports.createPackageResolutionDiagnostic = exports.createOfflineCacheMissDiagnostic = exports.createInvalidManifestDiagnostic = exports.createInvalidDependencyDiagnostic = exports.createAngularSingletonVersionConflictDiagnostic = exports.createAngularSingletonDuplicateDiagnostic = exports.createAngularPeerDependencyUnpinnedDiagnostic = exports.createCdnPackageSource = void 0;
 var cdn_source_1 = require("./cdn-source");
 Object.defineProperty(exports, "createCdnPackageSource", { enumerable: true, get: function () { return cdn_source_1.createCdnPackageSource; } });
 var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createAngularPeerDependencyUnpinnedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularPeerDependencyUnpinnedDiagnostic; } });
+Object.defineProperty(exports, "createAngularSingletonDuplicateDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularSingletonDuplicateDiagnostic; } });
+Object.defineProperty(exports, "createAngularSingletonVersionConflictDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularSingletonVersionConflictDiagnostic; } });
 Object.defineProperty(exports, "createInvalidDependencyDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidDependencyDiagnostic; } });
 Object.defineProperty(exports, "createInvalidManifestDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidManifestDiagnostic; } });
 Object.defineProperty(exports, "createOfflineCacheMissDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createOfflineCacheMissDiagnostic; } });

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

@@ -1,4 +1,4 @@
-import type { ForgePackageResolutionResult, ForgePackageResolver, ForgePackageResolverOptions, ForgeResolvePackagesOptions } from "./types";
+import type { ForgePackageResolutionResult, ForgePackageResolver, ForgePackageResolverOptions, ForgeResolvePackagesOptions, ForgePackageManifest } from "./types";
 export declare class DefaultPackageResolver implements ForgePackageResolver {
     private readonly options;
     readonly capability: "package-resolution";
@@ -9,7 +9,7 @@ export declare class DefaultPackageResolver implements ForgePackageResolver {
     private readonly manifestPath;
     private readonly now;
     constructor(options: ForgePackageResolverOptions);
-    readManifest(manifestPath?: string): Promise<import("./types").ForgePackageManifest>;
+    readManifest(manifestPath?: string): Promise<ForgePackageManifest>;
     resolve(options?: ForgeResolvePackagesOptions): Promise<ForgePackageResolutionResult>;
     private resolveRequest;
     private readCachedPackage;
@@ -17,4 +17,4 @@ export declare class DefaultPackageResolver implements ForgePackageResolver {
     private emitTelemetry;
 }
 export declare function createPackageResolver(options: ForgePackageResolverOptions): ForgePackageResolver;
-export declare function createPackageCacheKey(packageName: string, versionOrRange: string): string;
+export declare function createPackageCacheKey(packageName: string, versionOrRange: string, peerDependencyPins?: Readonly<Record<string, string>> | undefined): string;

package/dist/package-resolution/resolver.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPackageCacheKey = exports.createPackageResolver = exports.DefaultPackageResolver = void 0;
 const virtual_file_system_1 = require("../virtual-file-system");
+const framework_compatibility_1 = require("../framework-compatibility");
 const telemetry_1 = require("../telemetry");
 const manifest_1 = require("./manifest");
 const diagnostics_1 = require("./diagnostics");
@@ -32,12 +33,15 @@ class DefaultPackageResolver {
         let requests;
         try {
             const manifest = await this.readManifest(options.manifestPath ?? this.manifestPath);
-            requests = (0, manifest_1.collectDependencyRequests)(manifest);
+            const angularOptions = (0, framework_compatibility_1.resolveAngularCompatibilityOptions)(manifest, (options.frameworkCompatibility ?? this.options.frameworkCompatibility)
+                ?.angular);
+            requests = mergeDependencyRequests(manifest, (0, manifest_1.collectDependencyRequests)(manifest), options.additionalDependencies ?? []);
             const packages = [];
             const warnings = [];
             for (const request of requests) {
                 try {
-                    const result = await this.resolveRequest(request, sources, cacheMode);
+                    const compatibilityRequest = applyAngularPeerDependencyPins(request, manifest, packages, angularOptions);
+                    const result = await this.resolveRequest(compatibilityRequest, sources, cacheMode);
                     packages.push(result.packageRecord);
                     warnings.push(...result.warnings);
                 }
@@ -53,6 +57,13 @@ class DefaultPackageResolver {
                 }
             }
             packages.sort((left, right) => left.name.localeCompare(right.name));
+            const validationDiagnostics = validateAngularPackageResolution(manifest, packages, angularOptions);
+            if (validationDiagnostics.length > 0) {
+                throw new errors_1.ForgePackageResolutionError(validationDiagnostics[0], [
+                    ...warnings,
+                    ...validationDiagnostics.slice(1),
+                ]);
+            }
             const lock = createLockMetadata(packages, resolutionMode);
             const resultBase = {
                 manifest,
@@ -123,7 +134,7 @@ class DefaultPackageResolver {
         if (this.options.storage === undefined) {
             return undefined;
         }
-        const cacheRecord = await this.options.storage.getPackageCacheRecord(createPackageCacheKey(request.name, request.requestedRange));
+        const cacheRecord = await this.options.storage.getPackageCacheRecord(createPackageCacheKey(request.name, request.requestedRange, request.peerDependencyPins));
         if (cacheRecord === undefined || !isForgePackageRecord(cacheRecord.value)) {
             return undefined;
         }
@@ -138,10 +149,10 @@ class DefaultPackageResolver {
         }
         const warnings = [];
         const records = [
-            createCacheRecord(createPackageCacheKey(request.name, request.requestedRange), packageRecord, this.now()),
+            createCacheRecord(createPackageCacheKey(request.name, request.requestedRange, request.peerDependencyPins), packageRecord, this.now()),
         ];
         if (request.requestedRange !== packageRecord.version) {
-            records.push(createCacheRecord(createPackageCacheKey(request.name, packageRecord.version), packageRecord, this.now()));
+            records.push(createCacheRecord(createPackageCacheKey(request.name, packageRecord.version, request.peerDependencyPins), packageRecord, this.now()));
         }
         for (const record of records) {
             try {
@@ -180,11 +191,134 @@ function createPackageResolver(options) {
     return new DefaultPackageResolver(options);
 }
 exports.createPackageResolver = createPackageResolver;
-function createPackageCacheKey(packageName, versionOrRange) {
-    return `package:${encodeURIComponent(packageName)}@${encodeURIComponent(versionOrRange)}`;
+function createPackageCacheKey(packageName, versionOrRange, peerDependencyPins = undefined) {
+    const baseKey = `package:${encodeURIComponent(packageName)}@${encodeURIComponent(versionOrRange)}`;
+    const pins = formatPeerDependencyPins(peerDependencyPins);
+    return pins.length === 0
+        ? baseKey
+        : `${baseKey}?deps=${encodeURIComponent(pins.join(","))}`;
 }
 exports.createPackageCacheKey = createPackageCacheKey;
+function mergeDependencyRequests(manifest, requests, additionalRequests) {
+    if (additionalRequests.length === 0) {
+        return requests;
+    }
+    const merged = new Map(requests.map((request) => [request.name, request]));
+    for (const request of additionalRequests) {
+        if (!isValidAdditionalDependencyRequest(request)) {
+            throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidDependencyDiagnostic)(request.name, request.requestedRange, "Additional dependency request is invalid."));
+        }
+        const existing = merged.get(request.name);
+        if (existing !== undefined) {
+            if (existing.requestedRange !== request.requestedRange) {
+                throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createInvalidDependencyDiagnostic)(request.name, request.requestedRange, "Additional dependency conflicts with the workspace manifest."));
+            }
+            continue;
+        }
+        merged.set(request.name, request);
+    }
+    return Array.from(merged.values()).sort((left, right) => compareDependencyRequests(left, right, manifest));
+}
+function applyAngularPeerDependencyPins(request, manifest, packageRecords, angularOptions) {
+    if (!(0, framework_compatibility_1.shouldApplyAngularPeerDependencyPins)(request.name, angularOptions)) {
+        return request;
+    }
+    const pins = (0, framework_compatibility_1.createAngularPeerDependencyPinMap)(manifest, packageRecords, angularOptions);
+    return Object.keys(pins).length === 0
+        ? request
+        : {
+            ...request,
+            peerDependencyPins: pins,
+        };
+}
+function validateAngularPackageResolution(manifest, packages, angularOptions) {
+    if (!angularOptions.enabled) {
+        return [];
+    }
+    const diagnostics = [];
+    for (const packageRecord of packages) {
+        if ((0, framework_compatibility_1.isAngularSingletonPackage)(packageRecord.name, angularOptions)) {
+            const requestedVersion = (0, framework_compatibility_1.normalizeVersionPin)(packageRecord.requestedRange);
+            if (requestedVersion !== undefined &&
+                isExactVersionRequest(packageRecord.requestedRange) &&
+                requestedVersion !== packageRecord.version) {
+                diagnostics.push((0, diagnostics_1.createAngularSingletonVersionConflictDiagnostic)(packageRecord.name, packageRecord.requestedRange));
+            }
+            if (hasDependencyWrappedEntryUrl(packageRecord)) {
+                diagnostics.push((0, diagnostics_1.createAngularSingletonDuplicateDiagnostic)(packageRecord.name, packageRecord.requestedRange));
+            }
+            continue;
+        }
+        if (!packageUsesAngularSingleton(packageRecord, angularOptions)) {
+            continue;
+        }
+        const pins = packageRecord.peerDependencyPins ?? {};
+        for (const singletonName of angularOptions.singletonPackages) {
+            if (packageImportsAngularSingleton(packageRecord, singletonName) &&
+                pins[singletonName] === undefined &&
+                hasManifestDependency(manifest, singletonName)) {
+                diagnostics.push((0, diagnostics_1.createAngularPeerDependencyUnpinnedDiagnostic)(packageRecord.name, packageRecord.requestedRange));
+                break;
+            }
+        }
+    }
+    return diagnostics;
+}
+function isValidAdditionalDependencyRequest(request) {
+    return (request.name.length > 0 &&
+        request.requestedRange.trim().length > 0 &&
+        (request.kind === "dependency" || request.kind === "devDependency"));
+}
+function compareDependencyRequests(left, right, manifest) {
+    const leftDeclared = hasManifestDependency(manifest, left.name);
+    const rightDeclared = hasManifestDependency(manifest, right.name);
+    if (leftDeclared !== rightDeclared) {
+        return leftDeclared ? -1 : 1;
+    }
+    const nameComparison = left.name.localeCompare(right.name);
+    if (nameComparison !== 0) {
+        return nameComparison;
+    }
+    return left.kind.localeCompare(right.kind);
+}
+function hasManifestDependency(manifest, packageName) {
+    return (packageName in manifest.dependencies ||
+        packageName in manifest.devDependencies);
+}
+function hasDependencyWrappedEntryUrl(packageRecord) {
+    if (packageRecord.entryUrl === undefined) {
+        return false;
+    }
+    const queryIndex = packageRecord.entryUrl.indexOf("?");
+    if (queryIndex === -1) {
+        return false;
+    }
+    const query = packageRecord.entryUrl.slice(queryIndex + 1);
+    return /(?:^|[?&])deps=/.test(query) || /(?:^|[?&])external=/.test(query);
+}
+function isExactVersionRequest(requestedRange) {
+    return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(requestedRange.trim());
+}
+function packageUsesAngularSingleton(packageRecord, angularOptions) {
+    return angularOptions.singletonPackages.some((singletonName) => packageImportsAngularSingleton(packageRecord, singletonName));
+}
+function packageImportsAngularSingleton(packageRecord, singletonName) {
+    return (packageRecord.dependencies[singletonName] !== undefined ||
+        packageRecord.peerDependencies?.[singletonName] !== undefined ||
+        Object.values(packageRecord.files).some((file) => typeof file.content === "string" &&
+            (file.content.includes(`"${singletonName}"`) ||
+                file.content.includes(`'${singletonName}'`))));
+}
+function formatPeerDependencyPins(peerDependencyPins) {
+    return Object.entries(peerDependencyPins ?? {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, version]) => `${name}@${version}`);
+}
 function normalizePackageRecord(request, sourceId, packageRecord) {
+    const peerDependencyPins = {
+        ...(packageRecord.peerDependencyPins ?? {}),
+        ...(request.peerDependencyPins ?? {}),
+    };
     return {
         ...packageRecord,
         name: request.name,
@@ -193,6 +327,10 @@ function normalizePackageRecord(request, sourceId, packageRecord) {
         entry: normalizeEntryPath(packageRecord.entry),
         dependencies: { ...packageRecord.dependencies },
         files: { ...packageRecord.files },
+        peerDependencies: { ...(packageRecord.peerDependencies ?? {}) },
+        peerDependencyPins: Object.keys(peerDependencyPins).length > 0
+            ? peerDependencyPins
+            : undefined,
     };
 }
 function createLockMetadata(packages, resolutionMode) {
@@ -207,6 +345,7 @@ function createLockMetadata(packages, resolutionMode) {
             entry: packageRecord.entry,
             entryUrl: packageRecord.entryUrl,
             integrity: packageRecord.integrity,
+            peerDependencyPins: packageRecord.peerDependencyPins,
         })),
     };
 }

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

@@ -1,10 +1,11 @@
 import type { ForgeDiagnostic, ForgeVirtualFileSystemStorage } from "../virtual-file-system";
 import type { ForgeVirtualFileSystem } from "../virtual-file-system";
 import type { ForgeTelemetryReporter } from "../telemetry";
+import type { ForgeFrameworkCompatibilityOptions } from "../framework-compatibility";
 export declare const PACKAGE_RESOLUTION_CAPABILITY: "package-resolution";
 export type ForgePackageResolutionMode = "import-map" | "bundle-alias";
 export type ForgePackageCacheMode = "prefer-cache" | "cache-only";
-export type ForgePackageResolutionDiagnosticCode = "invalid_dependency" | "invalid_manifest" | "offline_cache_miss" | "unresolved_package" | "unsupported_range";
+export type ForgePackageResolutionDiagnosticCode = "angular_peer_dependency_unpinned" | "angular_singleton_duplicate" | "angular_singleton_version_conflict" | "invalid_dependency" | "invalid_manifest" | "offline_cache_miss" | "unresolved_package" | "unsupported_range";
 export interface ForgePackageResolutionDiagnostic {
     readonly code: ForgePackageResolutionDiagnosticCode;
     readonly severity: "error";
@@ -29,6 +30,7 @@ export interface ForgeDependencyRequest {
     readonly name: string;
     readonly requestedRange: string;
     readonly kind: ForgeDependencyKind;
+    readonly peerDependencyPins?: Readonly<Record<string, string>>;
 }
 export interface ForgePackageFile {
     readonly path: string;
@@ -48,6 +50,8 @@ export interface ForgePackageRecord {
     readonly dependencies: Record<string, string>;
     readonly files: Record<string, ForgePackageFile>;
     readonly integrity?: string;
+    readonly peerDependencies?: Record<string, string>;
+    readonly peerDependencyPins?: Readonly<Record<string, string>>;
 }
 export interface ForgePackageLockPackage {
     readonly name: string;
@@ -57,6 +61,7 @@ export interface ForgePackageLockPackage {
     readonly entry: string;
     readonly entryUrl?: string;
     readonly integrity?: string;
+    readonly peerDependencyPins?: Readonly<Record<string, string>>;
 }
 export interface ForgePackageLockMetadata {
     readonly lockfileVersion: 1;
@@ -77,6 +82,7 @@ export interface ForgePackageResolverOptions {
     readonly sources?: readonly ForgePackageSource[];
     readonly resolutionMode?: ForgePackageResolutionMode;
     readonly cacheMode?: ForgePackageCacheMode;
+    readonly frameworkCompatibility?: ForgeFrameworkCompatibilityOptions;
     readonly telemetry?: ForgeTelemetryReporter;
     readonly manifestPath?: string;
     readonly now?: () => string;
@@ -85,6 +91,8 @@ export interface ForgeResolvePackagesOptions {
     readonly sources?: readonly ForgePackageSource[];
     readonly resolutionMode?: ForgePackageResolutionMode;
     readonly cacheMode?: ForgePackageCacheMode;
+    readonly additionalDependencies?: readonly ForgeDependencyRequest[];
+    readonly frameworkCompatibility?: ForgeFrameworkCompatibilityOptions;
     readonly telemetry?: ForgeTelemetryReporter;
     readonly manifestPath?: string;
 }

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

@@ -43,7 +43,7 @@ class NpmRunDevCommandHandler {
                 stdout(`Forge started browser preview session ${startResult.session.id}.`),
                 stdout(`Preview URL: ${startResult.session.previewUrl}`),
                 stdout(`Preview revision ${startResult.session.revision} is ready as iframe HTML.`),
-                stdout("No real Vite server or TCP port was opened."),
+                stdout("No real dev server or TCP port was opened."),
                 ...warningOutput(startResult.diagnostics),
             ],
             diagnostics: startResult.diagnostics,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caryhu/codemine-forge",
-  "version": "0.0.1-alpha.3",
+  "version": "0.0.1-alpha.4",
   "description": "Browser-side runtime layer for Codemine demos.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",