@neon-rs/manifest 0.0.2 → 0.0.4

package/lib/abstract.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractManifest = exports.readManifest = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+async function readManifest(dir) {
+    dir = dir ?? process.cwd();
+    return JSON.parse(await fs.readFile(path.join(dir, "package.json"), { encoding: 'utf8' }));
+}
+exports.readManifest = readManifest;
+function assertIsPreamble(json) {
+    if (!json || typeof json !== 'object') {
+        throw new TypeError(`expected binary Neon package manifest, found ${json}`);
+    }
+    if (!('version' in json) || typeof json.version !== 'string') {
+        throw new TypeError('valid "version" string not found in Neon package manifest');
+    }
+    if (!('name' in json) || typeof json.name !== 'string') {
+        throw new TypeError('valid "name" string not found in Neon package manifest');
+    }
+}
+const OPTIONAL_KEYS = [
+    'author', 'repository', 'keywords', 'bugs', 'homepage', 'license', 'engines'
+];
+// export type OptionalKeys = {
+//   author?: string | undefined,
+//   repository?: string | undefined,
+//   keywords?: string[] | undefined,
+//   bugs?: string | object | undefined,
+//   homepage?: string | undefined,
+//   license?: string | undefined,
+//   engines?: object | undefined
+// };
+class AbstractManifest {
+    constructor(json) {
+        assertIsPreamble(json);
+        this._json = json;
+        this._changes = [];
+    }
+    get name() { return this._json.name; }
+    set name(value) { this._json.name = value; }
+    get version() { return this._json.version; }
+    set version(value) { this._json.version = value; }
+    get description() { return this._json.description ?? ""; }
+    hasUnsavedChanges() {
+        return this._changes.length > 0;
+    }
+    async save(dir, log) {
+        await fs.writeFile(path.join(dir, "package.json"), JSON.stringify(this._json, null, 2), { encoding: 'utf8' });
+    }
+    stringify() {
+        return JSON.stringify(this._json);
+    }
+    copyOptionalKeys(target) {
+        for (const key of OPTIONAL_KEYS) {
+            if (key in this._json) {
+                target[key] = this._json[key];
+            }
+        }
+    }
+}
+exports.AbstractManifest = AbstractManifest;

package/lib/abstract.d.cts

@@ -0,0 +1,25 @@
+import { Change } from './change.cjs';
+export declare function readManifest(dir?: string | undefined): Promise<unknown>;
+type Preamble = {
+    name: string;
+    version: string;
+    optionalDependencies?: Record<string, string> | undefined;
+    [key: string]: any;
+};
+export declare class AbstractManifest implements Preamble {
+    protected _json: Preamble;
+    protected _changes: Change[];
+    constructor(json: unknown);
+    get name(): string;
+    set name(value: string);
+    get version(): string;
+    set version(value: string);
+    get description(): string;
+    hasUnsavedChanges(): boolean;
+    save(dir: string, log: (msg: string) => void): Promise<void>;
+    stringify(): string;
+    copyOptionalKeys(target: {
+        [key: string]: unknown;
+    }): void;
+}
+export {};

package/lib/cache/cache.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cache/cache.d.cts

@@ -0,0 +1,9 @@
+import { NodePlatform, RustTarget } from '../platform.cjs';
+import { LibraryManifest } from '../index.cjs';
+export interface CacheCfg {
+    readonly type: string;
+    hasUnsavedChanges(): boolean;
+    setPlatformTarget(platform: NodePlatform, target: RustTarget): Promise<void>;
+    updatePlatforms(lib: LibraryManifest): boolean;
+    saveChanges(log: (msg: string) => void): Promise<void>;
+}

package/lib/cache/npm/legacy.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBinaryCfg = void 0;
+const platform_cjs_1 = require("../../platform.cjs");
+const util_cjs_1 = require("../../util.cjs");
+const neon_cjs_1 = require("../../library/neon.cjs");
+function assertIsBinaryV1(json) {
+    (0, util_cjs_1.assertHasProps)(['binary'], json, "neon");
+    const binary = json.binary;
+    if (!binary || typeof binary !== 'object') {
+        throw new TypeError(`expected "neon.binary" to be an object, found ${binary}`);
+    }
+    (0, util_cjs_1.assertHasProps)(['rust', 'node', 'platform', 'arch', 'abi'], binary, "neon.binary");
+    if (typeof binary.rust !== 'string' || !(0, platform_cjs_1.isRustTarget)(binary.rust)) {
+        throw new TypeError(`expected "neon.binary.rust" to be a valid Rust target, found ${binary.rust}`);
+    }
+    if (!(0, platform_cjs_1.isNodePlatform)(binary.node)) {
+        throw new TypeError(`expected "neon.binary.node" to be a valid Node platform, found ${binary.node}`);
+    }
+    if (typeof binary.platform !== 'string') {
+        throw new TypeError(`expected "neon.binary.platform" to be a string, found ${binary.platform}`);
+    }
+    if (typeof binary.arch !== 'string') {
+        throw new TypeError(`expected "neon.binary.arch" to be a string, found ${binary.arch}`);
+    }
+    if (binary.abi !== null && typeof binary.abi !== 'string') {
+        throw new TypeError(`expected "neon.binary.abi" to be a string or null, found ${binary.abi}`);
+    }
+}
+function assertIsBinaryV2(json) {
+    if (!json || typeof json !== 'object') {
+        throw new TypeError(`expected "neon" to be an object, found ${json}`);
+    }
+    (0, util_cjs_1.assertHasProps)(['rust', 'node', 'platform', 'arch', 'abi'], json, "neon");
+    if (!(0, platform_cjs_1.isRustTarget)(json.rust)) {
+        throw new TypeError(`expected "neon.rust" to be a valid Rust target, found ${json.rust}`);
+    }
+    if (!(0, platform_cjs_1.isNodePlatform)(json.node)) {
+        throw new TypeError(`expected "neon.node" to be a valid Node platform, found ${json.node}`);
+    }
+    if (typeof json.platform !== 'string') {
+        throw new TypeError(`expected "neon.platform" to be a string, found ${json.platform}`);
+    }
+    if (typeof json.arch !== 'string') {
+        throw new TypeError(`expected "neon.arch" to be a string, found ${json.arch}`);
+    }
+    if (json.abi !== null && typeof json.abi !== 'string') {
+        throw new TypeError(`expected "neon.abi" to be a string or null, found ${json.abi}`);
+    }
+}
+function normalizeBinaryCfg(json) {
+    (0, neon_cjs_1.assertHasNeonCfg)(json);
+    // V3 format: {
+    //   neon: {
+    //     type: 'binary',
+    //     rust: RustTarget,
+    //     node: NodeTarget,
+    //     os: string,
+    //     arch: string,
+    //     abi: string | null
+    //   }
+    // }
+    if ('type' in json.neon && 'os' in json.neon) {
+        return false;
+    }
+    // V2 format: {
+    //   neon: {
+    //     type: 'binary',
+    //     rust: RustTarget,
+    //     node: NodeTarget,
+    //     platform: string,
+    //     arch: string,
+    //     abi: string | null
+    //   }
+    // }
+    if ('type' in json.neon) {
+        json.neon = upgradeBinaryV2(json.neon);
+        return true;
+    }
+    // V1 format: {
+    //   neon: {
+    //     binary: {
+    //       rust: RustTarget,
+    //       node: NodeTarget,
+    //       platform: string,
+    //       arch: string,
+    //       abi: string | null
+    //     }
+    //   }
+    // }
+    json.neon = upgradeBinaryV1(json.neon);
+    return true;
+}
+exports.normalizeBinaryCfg = normalizeBinaryCfg;
+function upgradeBinaryV1(json) {
+    assertIsBinaryV1(json);
+    return {
+        type: 'binary',
+        rust: json.binary.rust,
+        node: json.binary.node,
+        os: json.binary.platform,
+        arch: json.binary.arch,
+        abi: json.binary.abi
+    };
+}
+function upgradeBinaryV2(json) {
+    assertIsBinaryV2(json);
+    return {
+        type: 'binary',
+        rust: json.rust,
+        node: json.node,
+        os: json.platform,
+        arch: json.arch,
+        abi: json.abi
+    };
+}

package/lib/cache/npm/legacy.d.cts

@@ -0,0 +1 @@
+export declare function normalizeBinaryCfg(json: object): boolean;

package/lib/cache/npm/manifest.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryManifest = exports.SCHEMA_VERSION = void 0;
+const platform_cjs_1 = require("../../platform.cjs");
+const neon_cjs_1 = require("../../library/neon.cjs");
+const util_cjs_1 = require("../../util.cjs");
+const legacy_cjs_1 = require("./legacy.cjs");
+exports.SCHEMA_VERSION = 3;
+function assertIsBinaryCfg(json) {
+    (0, util_cjs_1.assertHasProps)(['type', 'rust', 'node', 'os', 'arch', 'abi'], json, "neon");
+    if (json.type !== 'binary') {
+        throw new TypeError(`expected "neon.type" property to be "binary", found ${json.type}`);
+    }
+    if (typeof json.rust !== 'string' || !(0, platform_cjs_1.isRustTarget)(json.rust)) {
+        throw new TypeError(`expected "neon.rust" to be a valid Rust target, found ${json.rust}`);
+    }
+    if (typeof json.node !== 'string' || !(0, platform_cjs_1.isNodePlatform)(json.node)) {
+        throw new TypeError(`expected "neon.node" to be a valid Node target, found ${json.node}`);
+    }
+    if (typeof json.os !== 'string') {
+        throw new TypeError(`expected "neon.os" to be a string, found ${json.os}`);
+    }
+    if (typeof json.arch !== 'string') {
+        throw new TypeError(`expected "neon.arch" to be a string, found ${json.arch}`);
+    }
+    if (json.abi !== null && typeof json.abi !== 'string') {
+        throw new TypeError(`expected "neon.abi" to be a string or null, found ${json.abi}`);
+    }
+}
+function assertHasBinaryCfg(json) {
+    (0, neon_cjs_1.assertHasNeonCfg)(json);
+    assertIsBinaryCfg(json.neon);
+}
+class BinaryManifest extends util_cjs_1.AbstractManifest {
+    constructor(dir, json, isNew) {
+        super(json);
+        this.dir = dir;
+        this._schemaUpgraded = (0, legacy_cjs_1.normalizeBinaryCfg)(this._json);
+        this._targetChanged = false;
+        assertHasBinaryCfg(this._json);
+        this._binaryJSON = this._json;
+        this._new = isNew;
+    }
+    get isNew() {
+        return this._new;
+    }
+    get schemaUpgraded() {
+        return this._schemaUpgraded;
+    }
+    get targetChanged() {
+        return this._targetChanged;
+    }
+    cfg() {
+        return this._binaryJSON.neon;
+    }
+    setTarget(target) {
+        const targetInfo = (0, platform_cjs_1.describeTarget)(target);
+        this._json.os = targetInfo.os;
+        this._json.cpu = targetInfo.arch;
+        this._binaryJSON.neon.rust = target;
+        this._binaryJSON.neon.os = targetInfo.os;
+        this._binaryJSON.neon.arch = targetInfo.arch;
+        this._binaryJSON.neon.abi = targetInfo.abi;
+        this._targetChanged = true;
+    }
+    hasUnsavedChanges() {
+        return this._new || this._schemaUpgraded || this._targetChanged;
+    }
+    async save(log) {
+        await super.save(log);
+        this._new = false;
+        this._schemaUpgraded = false;
+        this._targetChanged = false;
+    }
+}
+exports.BinaryManifest = BinaryManifest;

package/lib/cache/npm/manifest.d.cts

@@ -0,0 +1,26 @@
+import { RustTarget, NodePlatform } from '../../platform.cjs';
+import { AbstractManifest, Preamble } from '../../util.cjs';
+export declare const SCHEMA_VERSION = 3;
+export interface BinaryCfg {
+    type: "binary";
+    rust: RustTarget;
+    node: NodePlatform;
+    os: string;
+    arch: string;
+    abi: string | null;
+}
+export declare class BinaryManifest extends AbstractManifest {
+    private _binaryJSON;
+    readonly dir: string;
+    private _schemaUpgraded;
+    private _targetChanged;
+    private _new;
+    constructor(dir: string, json: Preamble, isNew: boolean);
+    get isNew(): boolean;
+    get schemaUpgraded(): boolean;
+    get targetChanged(): boolean;
+    cfg(): BinaryCfg;
+    setTarget(target: RustTarget): void;
+    hasUnsavedChanges(): boolean;
+    save(log: (msg: string) => void): Promise<void>;
+}

package/lib/cache/npm/npm.cjs

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NPMCacheCfg = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const jscodeshift_1 = __importDefault(require("jscodeshift"));
+const platform_cjs_1 = require("../../platform.cjs");
+const package_cjs_1 = require("./package.cjs");
+const PLATFORMS_DIR = 'platforms';
+class NPMCacheCfg {
+    constructor(manifest, outDir = PLATFORMS_DIR) {
+        this.type = 'npm';
+        this.manifest = manifest;
+        this.dir = path.join(manifest.dir, outDir);
+        const packages = Object.create(null);
+        const platforms = manifest.allPlatforms();
+        for (const key in platforms) {
+            const node = key;
+            const rust = platforms[node];
+            packages[node] = package_cjs_1.BinaryPackage.defer(this, node, rust);
+        }
+        this._packages = packages;
+    }
+    async setPlatformTarget(platform, target) {
+        const pkg = this._packages[platform];
+        if (!pkg) {
+            this._packages[platform] = package_cjs_1.BinaryPackage.create(this, platform, target);
+        }
+        else {
+            await pkg.setTarget(target);
+        }
+    }
+    hasUnsavedChanges() {
+        for (const key in this._packages) {
+            const pkg = this._packages[key];
+            if (pkg.hasUnsavedChanges()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    newPlatforms() {
+        const result = [];
+        for (const node in this._packages) {
+            if (this._packages[node].isNew()) {
+                result.push(node);
+            }
+        }
+        return result;
+    }
+    async saveChanges(log) {
+        const newPlatforms = this.newPlatforms();
+        for (const node in this._packages) {
+            const pkg = this._packages[node];
+            if (pkg.hasUnsavedChanges()) {
+                await pkg.saveChanges(log);
+            }
+        }
+        if (newPlatforms.length > 0) {
+            await this.updateLoader(newPlatforms);
+        }
+    }
+    async updateLoader(platforms) {
+        const cfg = this.manifest.cfg();
+        if (!cfg.load) {
+            return;
+        }
+        const loaderPath = path.join(this.manifest.dir, cfg.load);
+        const loader = await fs.readFile(loaderPath, 'utf8');
+        function isPlatformTable(p) {
+            return p.value.properties.every(p => {
+                return p.type === 'Property' &&
+                    p.key.type === 'Literal' &&
+                    (0, platform_cjs_1.isNodePlatform)(p.key.value);
+            });
+        }
+        const result = (0, jscodeshift_1.default)(loader)
+            .find(jscodeshift_1.default.ObjectExpression)
+            .filter(isPlatformTable)
+            .replaceWith((p) => {
+            const newProps = platforms.map(platform => {
+                return jscodeshift_1.default.property('init', jscodeshift_1.default.literal(platform), jscodeshift_1.default.arrowFunctionExpression([], jscodeshift_1.default.callExpression(jscodeshift_1.default.identifier('require'), [jscodeshift_1.default.literal(`${cfg.org}/${platform}`)])));
+            });
+            return jscodeshift_1.default.objectExpression([...p.value.properties, ...newProps]);
+        })
+            .toSource({ quote: 'single' });
+        await fs.writeFile(loaderPath, result, 'utf8');
+    }
+    packageNames() {
+        const cfg = this.manifest.cfg();
+        return Object.keys(this.manifest.allPlatforms()).map(key => `${cfg.org}/${key}`);
+    }
+    updatePlatforms(lib) {
+        let changed = false;
+        const preamble = lib.preamble;
+        if (!preamble.optionalDependencies) {
+            preamble.optionalDependencies = {};
+            changed = true;
+        }
+        const packages = this.packageNames();
+        for (const pkg of packages) {
+            if (preamble.optionalDependencies[pkg] !== lib.version) {
+                preamble.optionalDependencies[pkg] = lib.version;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+}
+exports.NPMCacheCfg = NPMCacheCfg;

package/lib/cache/npm/npm.d.cts

@@ -0,0 +1,17 @@
+import { CacheCfg } from '../cache.cjs';
+import { LibraryManifest } from '../../library/library.cjs';
+import { RustTarget, NodePlatform } from '../../platform.cjs';
+export declare class NPMCacheCfg implements CacheCfg {
+    readonly type: string;
+    readonly dir: string;
+    readonly manifest: LibraryManifest;
+    private _packages;
+    constructor(manifest: LibraryManifest, outDir?: string);
+    setPlatformTarget(platform: NodePlatform, target: RustTarget): Promise<void>;
+    hasUnsavedChanges(): boolean;
+    private newPlatforms;
+    saveChanges(log: (msg: string) => void): Promise<void>;
+    updateLoader(platforms: NodePlatform[]): Promise<void>;
+    packageNames(): string[];
+    updatePlatforms(lib: LibraryManifest): boolean;
+}

package/lib/cache/npm/package.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryPackage = void 0;
+const platform_cjs_1 = require("../../platform.cjs");
+const manifest_cjs_1 = require("./manifest.cjs");
+const util_cjs_1 = require("../../util.cjs");
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs/promises"));
+async function loadManifest(cacheCfg, node, rust) {
+    const dir = path.join(cacheCfg.dir, node);
+    const json = await (0, util_cjs_1.readManifest)(dir);
+    return new manifest_cjs_1.BinaryManifest(dir, json, false);
+}
+class BinaryPackage {
+    constructor(cacheCfg, node, rust, manifest) {
+        this._cacheCfg = cacheCfg;
+        this._node = node;
+        this._rust = rust;
+        this._manifest = manifest;
+    }
+    async manifest() {
+        if (!this._manifest) {
+            this._manifest = await loadManifest(this._cacheCfg, this._node, this._rust);
+        }
+        return this._manifest;
+    }
+    isNew() {
+        return !!(this._manifest && this._manifest.isNew);
+    }
+    schemaUpgraded() {
+        return !!(this._manifest && this._manifest.schemaUpgraded);
+    }
+    targetChanged() {
+        return !!(this._manifest && this._manifest.targetChanged);
+    }
+    hasUnsavedChanges() {
+        return this.isNew() || this.schemaUpgraded() || this.targetChanged();
+    }
+    async saveChanges(log) {
+        const manifest = await this.manifest();
+        if (this.isNew()) {
+            log(`prebuild manifest: ${manifest.stringify()}`);
+            log(`creating ${manifest.dir}`);
+            await fs.mkdir(manifest.dir, { recursive: true });
+            log(`created ${manifest.dir}`);
+            log(`creating ${manifest.dir}/README.md`);
+            await fs.writeFile(path.join(manifest.dir, "README.md"), `# \`${manifest.name}\`\n\n${manifest.description}\n`);
+            log(`creating ${manifest.dir}/package.json`);
+            await manifest.save(log);
+        }
+        else if (manifest.hasUnsavedChanges()) {
+            log(`saved changes to ${manifest.dir}/package.json`);
+            await manifest.save(log);
+        }
+    }
+    async setTarget(target) {
+        (await this.manifest()).setTarget(target);
+    }
+    // Lazily load a package. The manifest will actually be read from
+    // disk via this.manifest() the first time it's invoked.
+    static defer(cacheCfg, node, rust) {
+        return new BinaryPackage(cacheCfg, node, rust, null);
+    }
+    static create(cacheCfg, node, rust) {
+        const targetInfo = (0, platform_cjs_1.describeTarget)(rust);
+        const libraryManifest = cacheCfg.manifest;
+        const org = libraryManifest.cfg().org;
+        const name = `${org}/${node}`;
+        const json = {
+            name,
+            description: `Prebuilt binary package for \`${libraryManifest.name}\` on \`${targetInfo.node}\`.`,
+            version: libraryManifest.version,
+            os: [targetInfo.os],
+            cpu: [targetInfo.arch],
+            main: "index.node",
+            files: ["index.node"],
+            neon: {
+                type: "binary",
+                rust: rust,
+                node: targetInfo.node,
+                os: targetInfo.os,
+                arch: targetInfo.arch,
+                abi: targetInfo.abi
+            }
+        };
+        libraryManifest.copyOptionalKeys(json);
+        const binaryManifest = new manifest_cjs_1.BinaryManifest(path.join(cacheCfg.dir, node), json, true);
+        return new BinaryPackage(cacheCfg, node, rust, binaryManifest);
+    }
+}
+exports.BinaryPackage = BinaryPackage;

package/lib/cache/npm/package.d.cts

@@ -0,0 +1,19 @@
+import { NPMCacheCfg } from "./npm.cjs";
+import { RustTarget, NodePlatform } from "../../platform.cjs";
+import { BinaryManifest } from "./manifest.cjs";
+export declare class BinaryPackage {
+    private _cacheCfg;
+    private _node;
+    private _rust;
+    private _manifest;
+    constructor(cacheCfg: NPMCacheCfg, node: NodePlatform, rust: RustTarget, manifest: BinaryManifest | null);
+    manifest(): Promise<BinaryManifest>;
+    isNew(): boolean;
+    schemaUpgraded(): boolean;
+    targetChanged(): boolean;
+    hasUnsavedChanges(): boolean;
+    saveChanges(log: (msg: string) => void): Promise<void>;
+    setTarget(target: RustTarget): Promise<void>;
+    static defer(cacheCfg: NPMCacheCfg, node: NodePlatform, rust: RustTarget): BinaryPackage;
+    static create(cacheCfg: NPMCacheCfg, node: NodePlatform, rust: RustTarget): BinaryPackage;
+}