@pagepocket/cli 0.11.0 → 0.12.0

package/dist/services/strategy/strategy-service.js

@@ -1,42 +1,39 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StrategyService = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const config_service_1 = require("../config-service");
-const parse_pinned_spec_1 = require("../user-packages/parse-pinned-spec");
-const unit_store_1 = require("../units/unit-store");
-const array_1 = require("../../utils/array");
-const strategy_analyze_1 = require("./strategy-analyze");
-const strategy_config_1 = require("./strategy-config");
-const strategy_fetch_1 = require("./strategy-fetch");
-const strategy_io_1 = require("./strategy-io");
-const strategy_normalize_1 = require("./strategy-normalize");
-const strategy_pack_read_1 = require("./strategy-pack-read");
-const strategy_pack_store_1 = require("./strategy-pack-store");
-class StrategyService {
-    constructor(configService = new config_service_1.ConfigService()) {
+import fs from "node:fs";
+import { uniq } from "../../utils/array.js";
+import { ConfigService } from "../config-service.js";
+import { UnitStore } from "../units/unit-store.js";
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
+import { collectWantedVersions, computeConflicts, computeDrift, ensureNoInstalledVersionConflicts } from "./strategy-analyze.js";
+import { listStrategyNamesFromConfig, requireStrategyInstalled, withStrategyInConfig, withoutStrategyInConfig } from "./strategy-config.js";
+import { fetchStrategyFile } from "./strategy-fetch.js";
+import { getStrategyPath, getStrategiesDir, readStrategyFile, writeJsonAtomic } from "./strategy-io.js";
+import { normalizeStrategyUnits } from "./strategy-normalize.js";
+import { readStrategiesFromPackRoot } from "./strategy-pack-read.js";
+import { StrategyPackStore } from "./strategy-pack-store.js";
+export class StrategyService {
+    configService;
+    unitStore;
+    packStore;
+    constructor(configService = new ConfigService()) {
         this.configService = configService;
-        this.unitStore = new unit_store_1.UnitStore(configService);
-        this.packStore = new strategy_pack_store_1.StrategyPackStore(configService);
+        this.unitStore = new UnitStore(configService);
+        this.packStore = new StrategyPackStore(configService);
     }
     ensureConfigFileExists() {
         return this.configService.ensureConfigFileExists();
     }
     getStrategiesDir() {
-        return (0, strategy_io_1.getStrategiesDir)(this.configService);
+        return getStrategiesDir(this.configService);
     }
     getStrategyPath(name) {
-        return (0, strategy_io_1.getStrategyPath)(this.configService, name);
+        return getStrategyPath(this.configService, name);
     }
     readStrategy(name) {
-        return (0, strategy_io_1.readStrategyFile)(this.getStrategyPath(name));
+        return readStrategyFile(this.getStrategyPath(name));
     }
     listInstalledStrategyNames() {
         const config = this.configService.readConfigOrDefault();
-        return (0, strategy_config_1.listStrategyNamesFromConfig)(config);
+        return listStrategyNamesFromConfig(config);
     }
     async addStrategy(input) {
         this.configService.ensureConfigFileExists();
@@ -44,7 +41,7 @@ class StrategyService {
         const sourceTrimmed = input.source.trim();
         const isPinnedNpm = (() => {
             try {
-                (0, parse_pinned_spec_1.parsePinnedSpec)(sourceTrimmed);
+                parsePinnedSpec(sourceTrimmed);
                 return true;
             }
             catch {
@@ -54,35 +51,35 @@ class StrategyService {
         if (isPinnedNpm) {
             const pinned = this.packStore.installPinned(sourceTrimmed);
             const packRoot = this.packStore.resolvePackRoot(pinned.name);
-            const strategies = (0, strategy_pack_read_1.readStrategiesFromPackRoot)(packRoot);
+            const strategies = readStrategiesFromPackRoot(packRoot);
             if (strategies.length === 0) {
                 throw new Error(`No *.strategy.json found in package: ${pinned.spec}`);
             }
-            const allUnits = strategies.flatMap((s) => (0, strategy_normalize_1.normalizeStrategyUnits)(s));
-            const refs = (0, array_1.uniq)(allUnits.map((u) => u.ref));
-            (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(this.unitStore.readInstalledDependencyVersions(), refs);
+            const allUnits = strategies.flatMap((strategy) => normalizeStrategyUnits(strategy));
+            const refs = uniq(allUnits.map((unit) => unit.ref));
+            ensureNoInstalledVersionConflicts(this.unitStore.readInstalledDependencyVersions(), refs);
             refs.forEach((ref) => this.unitStore.installPinned(ref));
             const installedStrategies = [];
             strategies.forEach((strategy) => {
                 const name = strategy.name;
                 const strategyPath = this.getStrategyPath(name);
-                if (!input.force && node_fs_1.default.existsSync(strategyPath)) {
+                if (!input.force && fs.existsSync(strategyPath)) {
                     return;
                 }
                 const toWrite = {
                     ...strategy,
                     source: { type: "npm", value: pinned.spec }
                 };
-                (0, strategy_io_1.writeJsonAtomic)(strategyPath, toWrite);
+                writeJsonAtomic(strategyPath, toWrite);
                 installedStrategies.push(name);
             });
-            const nextConfig = installedStrategies.reduce((acc, s) => (0, strategy_config_1.withStrategyInConfig)(acc, s), config);
+            const nextConfig = installedStrategies.reduce((configAccumulator, strategyName) => withStrategyInConfig(configAccumulator, strategyName), config);
             const existing = nextConfig.strategyPacks ?? [];
-            const filtered = existing.filter((x) => {
-                if (typeof x === "string") {
-                    return x.trim().length > 0;
+            const filtered = existing.filter((packEntry) => {
+                if (typeof packEntry === "string") {
+                    return packEntry.trim().length > 0;
                 }
-                return x.name !== pinned.name;
+                return packEntry.name !== pinned.name;
             });
             const strategyPacks = [
                 ...filtered,
@@ -94,61 +91,65 @@ class StrategyService {
             this.configService.writeConfig({ ...nextConfig, strategyPacks });
             return { installedRefs: refs, installedStrategies };
         }
-        const { strategy, source } = await (0, strategy_fetch_1.fetchStrategyFile)(sourceTrimmed);
-        const normalizedUnits = (0, strategy_normalize_1.normalizeStrategyUnits)(strategy);
-        const refs = (0, array_1.uniq)(normalizedUnits.map((u) => u.ref));
+        const { strategy, source } = await fetchStrategyFile(sourceTrimmed);
+        const normalizedUnits = normalizeStrategyUnits(strategy);
+        const refs = uniq(normalizedUnits.map((unit) => unit.ref));
         const strategyPath = this.getStrategyPath(strategy.name);
-        if (!input.force && node_fs_1.default.existsSync(strategyPath)) {
+        if (!input.force && fs.existsSync(strategyPath)) {
             throw new Error(`Strategy already exists: ${strategy.name}`);
         }
-        (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(this.unitStore.readInstalledDependencyVersions(), refs);
+        ensureNoInstalledVersionConflicts(this.unitStore.readInstalledDependencyVersions(), refs);
         refs.forEach((ref) => this.unitStore.installPinned(ref));
         const toWrite = {
             ...strategy,
             source
         };
-        (0, strategy_io_1.writeJsonAtomic)(strategyPath, toWrite);
-        this.configService.writeConfig((0, strategy_config_1.withStrategyInConfig)(config, strategy.name));
+        writeJsonAtomic(strategyPath, toWrite);
+        this.configService.writeConfig(withStrategyInConfig(config, strategy.name));
         return { installedRefs: refs, installedStrategies: [strategy.name] };
     }
     removeStrategy(name) {
         this.configService.ensureConfigFileExists();
         const config = this.configService.readConfigOrDefault();
-        (0, strategy_config_1.requireStrategyInstalled)(config, name);
+        requireStrategyInstalled(config, name);
         const strategyPath = this.getStrategyPath(name);
-        if (node_fs_1.default.existsSync(strategyPath)) {
-            node_fs_1.default.rmSync(strategyPath);
+        if (fs.existsSync(strategyPath)) {
+            fs.rmSync(strategyPath);
         }
-        this.configService.writeConfig((0, strategy_config_1.withoutStrategyInConfig)(config, name));
+        this.configService.writeConfig(withoutStrategyInConfig(config, name));
     }
     async updateStrategy(name, opts) {
         this.configService.ensureConfigFileExists();
         const config = this.configService.readConfigOrDefault();
-        const names = name ? [name] : (0, strategy_config_1.listStrategyNamesFromConfig)(config);
+        const names = name ? [name] : listStrategyNamesFromConfig(config);
         if (names.length === 0) {
             return;
         }
         const installed = this.unitStore.readInstalledDependencyVersions();
         if (opts?.packageOnly) {
-            const packageNames = (0, array_1.uniq)(names
-                .flatMap((n) => (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n)).map((u) => (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref).name))
-                .filter((x) => x.trim().length > 0));
+            const packageNames = uniq(names
+                .flatMap((strategyName) => normalizeStrategyUnits(this.readStrategy(strategyName)).map((unit) => parsePinnedSpec(unit.ref).name))
+                .filter((packageName) => packageName.trim().length > 0));
             packageNames.forEach((pkg) => {
                 this.unitStore.updateToLatest(pkg);
             });
             const afterInstalled = this.unitStore.readInstalledDependencyVersions();
-            const afterStrategies = (0, strategy_config_1.listStrategyNamesFromConfig)(config).map((n) => ({
-                name: n,
-                units: (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n))
+            const afterStrategies = listStrategyNamesFromConfig(config).map((strategyName) => ({
+                name: strategyName,
+                units: normalizeStrategyUnits(this.readStrategy(strategyName))
             }));
-            const wanted = (0, strategy_analyze_1.collectWantedVersions)(afterStrategies);
-            const conflicts = (0, strategy_analyze_1.computeConflicts)(wanted);
+            const wanted = collectWantedVersions(afterStrategies);
+            const conflicts = computeConflicts(wanted);
             if (conflicts.length > 0) {
                 throw new Error(`Strategy version conflicts detected (${conflicts.length}). Run 'pp strategy doctor' for details.`);
             }
             const drift = afterStrategies
-                .map((s) => (0, strategy_analyze_1.computeDrift)({ strategyName: s.name, units: s.units, installed: afterInstalled }))
-                .filter((d) => d.items.length > 0);
+                .map((strategy) => computeDrift({
+                strategyName: strategy.name,
+                units: strategy.units,
+                installed: afterInstalled
+            }))
+                .filter((drift) => drift.items.length > 0);
             if (drift.length > 0) {
                 throw new Error("Strategy drift detected after --package-only update. Run 'pp strategy doctor'.");
             }
@@ -156,119 +157,124 @@ class StrategyService {
         }
         const nextStrategies = [];
         const npmPacksToUpdate = new Set();
-        for (const n of names) {
-            const current = this.readStrategy(n);
+        for (const strategyName of names) {
+            const current = this.readStrategy(strategyName);
             const src = current.source;
             if (!src) {
-                throw new Error(`Strategy ${n} has no source. Re-add it with a URL/path source to enable update.`);
+                throw new Error(`Strategy ${strategyName} has no source. Re-add it with a URL/path source to enable update.`);
             }
             if (src.type === "npm") {
                 npmPacksToUpdate.add(src.value);
                 continue;
             }
-            const fetched = await (0, strategy_fetch_1.fetchStrategyFile)(src.value);
-            if (fetched.strategy.name !== n) {
-                throw new Error(`Strategy name mismatch while updating ${n}: got ${fetched.strategy.name}`);
+            const fetched = await fetchStrategyFile(src.value);
+            if (fetched.strategy.name !== strategyName) {
+                throw new Error(`Strategy name mismatch while updating ${strategyName}: got ${fetched.strategy.name}`);
             }
             const file = { ...fetched.strategy, source: fetched.source };
-            const units = (0, strategy_normalize_1.normalizeStrategyUnits)(file);
-            nextStrategies.push({ name: n, file, units });
+            const units = normalizeStrategyUnits(file);
+            nextStrategies.push({ name: strategyName, file, units });
         }
         if (npmPacksToUpdate.size > 0) {
             const specs = [...npmPacksToUpdate];
             specs.forEach((spec) => {
-                const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(spec);
+                const pinned = parsePinnedSpec(spec);
                 this.packStore.updateToLatest(pinned.name);
             });
             const installedPackVersions = this.packStore.readInstalledDependencyVersions();
             const updatedSpecs = specs.map((spec) => {
-                const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(spec);
-                const v = installedPackVersions[pinned.name];
-                if (!v) {
+                const pinned = parsePinnedSpec(spec);
+                const installedVersion = installedPackVersions[pinned.name];
+                if (!installedVersion) {
                     throw new Error(`Strategy pack not installed after update: ${pinned.name}`);
                 }
-                return `${pinned.name}@${v}`;
+                return `${pinned.name}@${installedVersion}`;
             });
             const updatedFiles = [];
             updatedSpecs.forEach((spec) => {
-                const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(spec);
+                const pinned = parsePinnedSpec(spec);
                 const root = this.packStore.resolvePackRoot(pinned.name);
-                const files = (0, strategy_pack_read_1.readStrategiesFromPackRoot)(root).map((f) => ({
-                    ...f,
+                const files = readStrategiesFromPackRoot(root).map((strategyFile) => ({
+                    ...strategyFile,
                     source: { type: "npm", value: spec }
                 }));
                 updatedFiles.push(...files);
             });
             updatedFiles.forEach((file) => {
-                const units = (0, strategy_normalize_1.normalizeStrategyUnits)(file);
+                const units = normalizeStrategyUnits(file);
                 nextStrategies.push({ name: file.name, file, units });
             });
             const nextConfig = this.configService.readConfigOrDefault();
             const existing = nextConfig.strategyPacks ?? [];
-            const filtered = existing.filter((x) => {
-                if (typeof x === "string") {
-                    return x.trim().length > 0;
+            const filtered = existing.filter((packEntry) => {
+                if (typeof packEntry === "string") {
+                    return packEntry.trim().length > 0;
                 }
-                return !updatedSpecs.some((spec) => (0, parse_pinned_spec_1.parsePinnedSpec)(spec).name === x.name);
+                return !updatedSpecs.some((spec) => parsePinnedSpec(spec).name === packEntry.name);
             });
             const packsNext = [
                 ...filtered,
                 ...updatedSpecs.map((spec) => {
-                    const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(spec);
+                    const pinned = parsePinnedSpec(spec);
                     return { name: pinned.name, spec: pinned.spec };
                 })
             ];
             this.configService.writeConfig({ ...nextConfig, strategyPacks: packsNext });
         }
-        const allOtherNames = (0, strategy_config_1.listStrategyNamesFromConfig)(config).filter((n) => !names.includes(n));
-        const otherStrategies = allOtherNames.map((n) => ({
-            name: n,
-            units: (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n))
+        const allOtherNames = listStrategyNamesFromConfig(config).filter((strategyName) => !names.includes(strategyName));
+        const otherStrategies = allOtherNames.map((strategyName) => ({
+            name: strategyName,
+            units: normalizeStrategyUnits(this.readStrategy(strategyName))
         }));
-        const wanted = (0, strategy_analyze_1.collectWantedVersions)([
+        const wanted = collectWantedVersions([
             ...otherStrategies,
-            ...nextStrategies.map((s) => ({ name: s.name, units: s.units }))
+            ...nextStrategies.map((strategy) => ({ name: strategy.name, units: strategy.units }))
         ]);
-        const conflicts = (0, strategy_analyze_1.computeConflicts)(wanted);
+        const conflicts = computeConflicts(wanted);
         if (conflicts.length > 0) {
             throw new Error(`Strategy version conflicts detected (${conflicts.length}). Run 'pp strategy doctor' for details.`);
         }
-        const refs = (0, array_1.uniq)(nextStrategies.flatMap((s) => s.units.map((u) => u.ref)));
-        (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(installed, refs);
+        const refs = uniq(nextStrategies.flatMap((strategy) => strategy.units.map((unit) => unit.ref)));
+        ensureNoInstalledVersionConflicts(installed, refs);
         refs.forEach((ref) => {
             this.unitStore.installPinned(ref);
         });
-        nextStrategies.forEach((s) => {
-            (0, strategy_io_1.writeJsonAtomic)(this.getStrategyPath(s.name), s.file);
+        nextStrategies.forEach((strategy) => {
+            writeJsonAtomic(this.getStrategyPath(strategy.name), strategy.file);
         });
     }
     pinStrategy(name) {
         this.configService.ensureConfigFileExists();
         const config = this.configService.readConfigOrDefault();
-        (0, strategy_config_1.requireStrategyInstalled)(config, name);
+        requireStrategyInstalled(config, name);
         const file = this.readStrategy(name);
-        const units = (0, strategy_normalize_1.normalizeStrategyUnits)(file);
+        const units = normalizeStrategyUnits(file);
         const installed = this.unitStore.readInstalledDependencyVersions();
-        const pinnedUnits = units.map((u) => {
-            const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref);
-            const v = installed[pinned.name];
-            if (!v) {
+        const pinnedUnits = units.map((unit) => {
+            const pinned = parsePinnedSpec(unit.ref);
+            const installedVersion = installed[pinned.name];
+            if (!installedVersion) {
                 throw new Error(`Unit package is not installed: ${pinned.name}`);
             }
-            const nextRef = `${pinned.name}@${v}`;
-            return u.args.length === 0 ? nextRef : { ref: nextRef, args: u.args };
+            const nextRef = `${pinned.name}@${installedVersion}`;
+            return unit.args.length === 0 ? nextRef : { ref: nextRef, args: unit.args };
         });
-        const others = (0, strategy_config_1.listStrategyNamesFromConfig)(config)
-            .filter((n) => n !== name)
-            .map((n) => ({ name: n, units: (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n)) }));
-        const nextWanted = (0, strategy_analyze_1.collectWantedVersions)([
+        const others = listStrategyNamesFromConfig(config)
+            .filter((strategyName) => strategyName !== name)
+            .map((strategyName) => ({
+            name: strategyName,
+            units: normalizeStrategyUnits(this.readStrategy(strategyName))
+        }));
+        const nextWanted = collectWantedVersions([
             ...others,
             {
                 name,
-                units: pinnedUnits.map((x) => typeof x === "string" ? { ref: x, args: [] } : { ref: x.ref, args: x.args ?? [] })
+                units: pinnedUnits.map((pinnedUnit) => typeof pinnedUnit === "string"
+                    ? { ref: pinnedUnit, args: [] }
+                    : { ref: pinnedUnit.ref, args: pinnedUnit.args ?? [] })
             }
         ]);
-        const conflicts = (0, strategy_analyze_1.computeConflicts)(nextWanted);
+        const conflicts = computeConflicts(nextWanted);
         if (conflicts.length > 0) {
             throw new Error(`Strategy version conflicts detected (${conflicts.length}). Run 'pp strategy doctor' for details.`);
         }
@@ -279,23 +285,22 @@ class StrategyService {
                 units: pinnedUnits
             }
         };
-        (0, strategy_io_1.writeJsonAtomic)(this.getStrategyPath(name), nextFile);
+        writeJsonAtomic(this.getStrategyPath(name), nextFile);
     }
     doctor() {
         this.configService.ensureConfigFileExists();
         const config = this.configService.readConfigOrDefault();
-        const names = (0, strategy_config_1.listStrategyNamesFromConfig)(config);
+        const names = listStrategyNamesFromConfig(config);
         const installed = this.unitStore.readInstalledDependencyVersions();
-        const strategies = names.map((n) => ({
-            name: n,
-            units: (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n))
+        const strategies = names.map((strategyName) => ({
+            name: strategyName,
+            units: normalizeStrategyUnits(this.readStrategy(strategyName))
         }));
-        const wanted = (0, strategy_analyze_1.collectWantedVersions)(strategies);
-        const conflicts = (0, strategy_analyze_1.computeConflicts)(wanted);
+        const wanted = collectWantedVersions(strategies);
+        const conflicts = computeConflicts(wanted);
         const drift = strategies
-            .map((s) => (0, strategy_analyze_1.computeDrift)({ strategyName: s.name, units: s.units, installed }))
-            .filter((d) => d.items.length > 0);
+            .map((strategy) => computeDrift({ strategyName: strategy.name, units: strategy.units, installed }))
+            .filter((drift) => drift.items.length > 0);
         return { conflicts, drift };
     }
 }
-exports.StrategyService = StrategyService;

package/dist/services/strategy/types.js

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

package/dist/services/units/unit-store.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnitStore = void 0;
-const user_package_installer_1 = require("../user-packages/user-package-installer");
-const parse_pinned_spec_1 = require("../user-packages/parse-pinned-spec");
-const user_package_store_1 = require("../user-packages/user-package-store");
-const unit_validate_1 = require("./unit-validate");
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
+import { installPinnedPackage, updatePackageToLatest } from "../user-packages/user-package-installer.js";
+import { UserPackageStore } from "../user-packages/user-package-store.js";
+import { isUnitLike, resolveUnitConstructor } from "./unit-validate.js";
 const UNITS_KIND = "units";
 const UNITS_PACKAGE_JSON_NAME = "pagepocket-user-units";
-class UnitStore {
+export class UnitStore {
+    store;
     constructor(configService) {
-        this.store = new user_package_store_1.UserPackageStore(configService, UNITS_KIND);
+        this.store = new UserPackageStore(configService, UNITS_KIND);
     }
     getInstallDir() {
         return this.store.getInstallDir();
@@ -21,14 +19,14 @@ class UnitStore {
         return this.store.readInstalledPackageMeta(UNITS_PACKAGE_JSON_NAME, packageName);
     }
     installPinned(ref) {
-        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(ref);
-        (0, user_package_installer_1.installPinnedPackage)(this.store, {
+        const pinned = parsePinnedSpec(ref);
+        installPinnedPackage(this.store, {
             packageJsonName: UNITS_PACKAGE_JSON_NAME,
             packageSpec: pinned.spec
         });
     }
     updateToLatest(packageName) {
-        (0, user_package_installer_1.updatePackageToLatest)(this.store, {
+        updatePackageToLatest(this.store, {
             packageJsonName: UNITS_PACKAGE_JSON_NAME,
             packageName
         });
@@ -37,18 +35,16 @@ class UnitStore {
         return this.store.importModule(UNITS_PACKAGE_JSON_NAME, packageName);
     }
     async instantiateFromRef(ref, args) {
-        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(ref);
+        const pinned = parsePinnedSpec(ref);
         const mod = await this.importUnitModule(pinned.name);
-        const def = mod.default;
-        if (typeof def !== "function") {
-            throw new Error(`Unit ${pinned.name} must default export a constructor.`);
+        const ctor = resolveUnitConstructor(mod);
+        if (!ctor) {
+            throw new Error(`Unit ${pinned.name} does not export a Unit constructor.`);
         }
-        const ctor = def;
         const instance = new ctor(...args);
-        if (!(0, unit_validate_1.isUnitLike)(instance)) {
-            throw new Error(`Unit ${pinned.name} default export did not construct a Unit.`);
+        if (!isUnitLike(instance)) {
+            throw new Error(`Unit ${pinned.name} exported constructor did not produce a Unit.`);
         }
         return instance;
     }
 }
-exports.UnitStore = UnitStore;

package/dist/services/units/unit-validate.js

@@ -1,13 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUnitLike = void 0;
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const isCallable = (value) => {
-    return typeof value === "function";
-};
-const isUnitLike = (value) => {
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isCallable = (value) => typeof value === "function";
+export const isUnitLike = (value) => {
     if (!isRecord(value)) {
         return false;
     }
@@ -25,4 +18,23 @@ const isUnitLike = (value) => {
     }
     return true;
 };
-exports.isUnitLike = isUnitLike;
+/**
+ * Resolve a Unit constructor from an imported ESM module.
+ *
+ * Checks `mod.default` first. If it is not a function (e.g. older packages
+ * that only use named exports), falls back to the first exported function
+ * whose name ends with "Unit".
+ *
+ * @returns The constructor function, or `undefined` when none is found.
+ */
+export const resolveUnitConstructor = (mod) => {
+    if (typeof mod.default === "function") {
+        return mod.default;
+    }
+    const fallback = Object.values(mod).find((exportedValue) => typeof exportedValue === "function" &&
+        exportedValue.name?.endsWith("Unit"));
+    if (typeof fallback === "function") {
+        return fallback;
+    }
+    return undefined;
+};

package/dist/services/user-packages/parse-pinned-spec.js

@@ -1,23 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePinnedSpec = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const node_module_1 = require("node:module");
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const isExactSemver = (value) => {
-    return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value);
-};
-const parsePinnedSpec = (input) => {
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isExactSemver = (value) => /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value);
+export const parsePinnedSpec = (input) => {
     const trimmed = input.trim();
     if (!trimmed) {
         throw new Error("package spec is empty");
     }
-    const req = (0, node_module_1.createRequire)(typeof __filename === "string" ? __filename : node_path_1.default.join(process.cwd(), "package.json"));
+    const req = createRequire(import.meta.url ? fileURLToPath(import.meta.url) : path.join(process.cwd(), "package.json"));
     const npa = req("npm-package-arg");
     const parsed = npa(trimmed);
     if (!isRecord(parsed)) {
@@ -40,4 +31,3 @@ const parsePinnedSpec = (input) => {
     }
     return { name, version: rawSpec, spec: `${name}@${rawSpec}` };
 };
-exports.parsePinnedSpec = parsePinnedSpec;

package/dist/services/user-packages/user-package-installer.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updatePackageToLatest = exports.installPinnedPackage = void 0;
-const node_child_process_1 = require("node:child_process");
+import { spawnSync } from "node:child_process";
 const toError = (value) => {
     if (value instanceof Error) {
         return value;
@@ -9,16 +6,16 @@ const toError = (value) => {
     return new Error(String(value));
 };
 const tryRun = (cwd, cmd, args) => {
-    const r = (0, node_child_process_1.spawnSync)(cmd, args, {
+    const result = spawnSync(cmd, args, {
         cwd,
         stdio: "inherit",
         shell: false
     });
-    if (r.error) {
-        return { ok: false, error: toError(r.error) };
+    if (result.error) {
+        return { ok: false, error: toError(result.error) };
     }
-    if (typeof r.status === "number" && r.status !== 0) {
-        return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+    if (typeof result.status === "number" && result.status !== 0) {
+        return { ok: false, error: new Error(`${cmd} exited with code ${result.status}`) };
     }
     return { ok: true };
 };
@@ -33,15 +30,13 @@ const installWithFallback = (installDir, packageSpec) => {
     }
     throw new Error(`Failed to install ${packageSpec}. Ensure pnpm or npm is available.`);
 };
-const installPinnedPackage = (store, input) => {
+export const installPinnedPackage = (store, input) => {
     store.ensureInstallDirPackageJson(input.packageJsonName);
     const installDir = store.getInstallDir();
     installWithFallback(installDir, input.packageSpec);
 };
-exports.installPinnedPackage = installPinnedPackage;
-const updatePackageToLatest = (store, input) => {
+export const updatePackageToLatest = (store, input) => {
     store.ensureInstallDirPackageJson(input.packageJsonName);
     const installDir = store.getInstallDir();
     installWithFallback(installDir, `${input.packageName}@latest`);
 };
-exports.updatePackageToLatest = updatePackageToLatest;