@pagepocket/cli 0.10.1 → 0.11.1

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeStrategyUnits = void 0;
-const parse_pinned_spec_1 = require("../user-packages/parse-pinned-spec");
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 const isRecord = (value) => {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 };
@@ -23,7 +20,7 @@ const isJsonValue = (value) => {
 };
 const normalizeUnitSpec = (spec, idx) => {
     if (typeof spec === "string") {
-        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(spec);
+        const pinned = parsePinnedSpec(spec);
         return { ref: pinned.spec, args: [] };
     }
     if (!isRecord(spec)) {
@@ -33,7 +30,7 @@ const normalizeUnitSpec = (spec, idx) => {
     if (typeof ref !== "string") {
         throw new Error(`Invalid unit ref at index ${idx}`);
     }
-    const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(ref);
+    const pinned = parsePinnedSpec(ref);
     const argsRaw = spec.args;
     const args = typeof argsRaw === "undefined" ? [] : argsRaw;
     if (!Array.isArray(args)) {
@@ -44,8 +41,7 @@ const normalizeUnitSpec = (spec, idx) => {
     }
     return { ref: pinned.spec, args };
 };
-const normalizeStrategyUnits = (strategy) => {
+export const normalizeStrategyUnits = (strategy) => {
     const units = strategy.pipeline.units;
     return units.map((spec, idx) => normalizeUnitSpec(spec, idx));
 };
-exports.normalizeStrategyUnits = normalizeStrategyUnits;

package/dist/services/strategy/strategy-pack-read.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readStrategiesFromPackRoot = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const parse_json_1 = require("../../utils/parse-json");
+import fs from "node:fs";
+import path from "node:path";
+import { parseJson } from "../../utils/parse-json.js";
 const isRecord = (value) => {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 };
@@ -29,19 +23,19 @@ const isStrategyFile = (value) => {
     }
     return true;
 };
-const readStrategiesFromPackRoot = (packRoot) => {
-    const strategiesDir = node_path_1.default.join(packRoot, "strategies");
-    if (!node_fs_1.default.existsSync(strategiesDir)) {
+export const readStrategiesFromPackRoot = (packRoot) => {
+    const strategiesDir = path.join(packRoot, "strategies");
+    if (!fs.existsSync(strategiesDir)) {
         return [];
     }
-    const fileNames = node_fs_1.default
+    const fileNames = fs
         .readdirSync(strategiesDir)
         .filter((f) => f.endsWith(".strategy.json"))
         .sort((a, b) => a.localeCompare(b));
     return fileNames.map((fileName) => {
-        const filePath = node_path_1.default.join(strategiesDir, fileName);
-        const text = node_fs_1.default.readFileSync(filePath, "utf8");
-        const parsed = (0, parse_json_1.parseJson)(text);
+        const filePath = path.join(strategiesDir, fileName);
+        const text = fs.readFileSync(filePath, "utf8");
+        const parsed = parseJson(text);
         if (!parsed.ok) {
             throw parsed.error;
         }
@@ -51,4 +45,3 @@ const readStrategiesFromPackRoot = (packRoot) => {
         return parsed.value;
     });
 };
-exports.readStrategiesFromPackRoot = readStrategiesFromPackRoot;

package/dist/services/strategy/strategy-pack-store.js

@@ -1,19 +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.StrategyPackStore = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const user_package_installer_1 = require("../user-packages/user-package-installer");
-const user_package_installer_2 = 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");
+import path from "node:path";
+import { installPinnedPackage } from "../user-packages/user-package-installer.js";
+import { updatePackageToLatest } from "../user-packages/user-package-installer.js";
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
+import { UserPackageStore } from "../user-packages/user-package-store.js";
 const STRATEGY_PACKS_KIND = "strategy-packs";
 const STRATEGY_PACKS_PACKAGE_JSON_NAME = "pagepocket-user-strategy-packs";
-class StrategyPackStore {
+export class StrategyPackStore {
+    store;
     constructor(configService) {
-        this.store = new user_package_store_1.UserPackageStore(configService, STRATEGY_PACKS_KIND);
+        this.store = new UserPackageStore(configService, STRATEGY_PACKS_KIND);
     }
     getInstallDir() {
         return this.store.getInstallDir();
@@ -22,15 +17,15 @@ class StrategyPackStore {
         return this.store.readInstalledDependencyVersions(STRATEGY_PACKS_PACKAGE_JSON_NAME);
     }
     installPinned(spec) {
-        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(spec);
-        (0, user_package_installer_1.installPinnedPackage)(this.store, {
+        const pinned = parsePinnedSpec(spec);
+        installPinnedPackage(this.store, {
             packageJsonName: STRATEGY_PACKS_PACKAGE_JSON_NAME,
             packageSpec: pinned.spec
         });
         return pinned;
     }
     updateToLatest(packageName) {
-        (0, user_package_installer_2.updatePackageToLatest)(this.store, {
+        updatePackageToLatest(this.store, {
             packageJsonName: STRATEGY_PACKS_PACKAGE_JSON_NAME,
             packageName
         });
@@ -39,7 +34,6 @@ class StrategyPackStore {
         this.store.ensureInstallDirPackageJson(STRATEGY_PACKS_PACKAGE_JSON_NAME);
         const req = this.store.createRequire(STRATEGY_PACKS_PACKAGE_JSON_NAME);
         const pkgJsonPath = req.resolve(`${packageName}/package.json`);
-        return node_path_1.default.dirname(pkgJsonPath);
+        return path.dirname(pkgJsonPath);
     }
 }
-exports.StrategyPackStore = StrategyPackStore;

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

@@ -1,41 +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 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 { ConfigService } from "../config-service.js";
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
+import { UnitStore } from "../units/unit-store.js";
+import { uniq } from "../../utils/array.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();
@@ -43,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 {
@@ -53,29 +51,29 @@ 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, strategy_analyze_1.uniq)(allUnits.map((u) => u.ref));
-            (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(this.unitStore.readInstalledDependencyVersions(), refs);
+            const allUnits = strategies.flatMap((s) => normalizeStrategyUnits(s));
+            const refs = uniq(allUnits.map((u) => u.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((acc, s) => withStrategyInConfig(acc, s), config);
             const existing = nextConfig.strategyPacks ?? [];
             const filtered = existing.filter((x) => {
                 if (typeof x === "string") {
@@ -93,60 +91,60 @@ 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, strategy_analyze_1.uniq)(normalizedUnits.map((u) => u.ref));
+        const { strategy, source } = await fetchStrategyFile(sourceTrimmed);
+        const normalizedUnits = normalizeStrategyUnits(strategy);
+        const refs = uniq(normalizedUnits.map((u) => u.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, strategy_analyze_1.uniq)(names
-                .flatMap((n) => (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n)).map((u) => (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref).name))
+            const packageNames = uniq(names
+                .flatMap((n) => normalizeStrategyUnits(this.readStrategy(n)).map((u) => parsePinnedSpec(u.ref).name))
                 .filter((x) => x.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) => ({
+            const afterStrategies = listStrategyNamesFromConfig(config).map((n) => ({
                 name: n,
-                units: (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n))
+                units: normalizeStrategyUnits(this.readStrategy(n))
             }));
-            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 }))
+                .map((s) => computeDrift({ strategyName: s.name, units: s.units, installed: afterInstalled }))
                 .filter((d) => d.items.length > 0);
             if (drift.length > 0) {
                 throw new Error("Strategy drift detected after --package-only update. Run 'pp strategy doctor'.");
@@ -165,23 +163,23 @@ class StrategyService {
                 npmPacksToUpdate.add(src.value);
                 continue;
             }
-            const fetched = await (0, strategy_fetch_1.fetchStrategyFile)(src.value);
+            const fetched = await fetchStrategyFile(src.value);
             if (fetched.strategy.name !== n) {
                 throw new Error(`Strategy name mismatch while updating ${n}: got ${fetched.strategy.name}`);
             }
             const file = { ...fetched.strategy, source: fetched.source };
-            const units = (0, strategy_normalize_1.normalizeStrategyUnits)(file);
+            const units = normalizeStrategyUnits(file);
             nextStrategies.push({ name: n, 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 pinned = parsePinnedSpec(spec);
                 const v = installedPackVersions[pinned.name];
                 if (!v) {
                     throw new Error(`Strategy pack not installed after update: ${pinned.name}`);
@@ -190,16 +188,16 @@ class StrategyService {
             });
             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) => ({
+                const files = readStrategiesFromPackRoot(root).map((f) => ({
                     ...f,
                     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();
@@ -208,48 +206,48 @@ class StrategyService {
                 if (typeof x === "string") {
                     return x.trim().length > 0;
                 }
-                return !updatedSpecs.some((spec) => (0, parse_pinned_spec_1.parsePinnedSpec)(spec).name === x.name);
+                return !updatedSpecs.some((spec) => parsePinnedSpec(spec).name === x.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 allOtherNames = listStrategyNamesFromConfig(config).filter((n) => !names.includes(n));
         const otherStrategies = allOtherNames.map((n) => ({
             name: n,
-            units: (0, strategy_normalize_1.normalizeStrategyUnits)(this.readStrategy(n))
+            units: normalizeStrategyUnits(this.readStrategy(n))
         }));
-        const wanted = (0, strategy_analyze_1.collectWantedVersions)([
+        const wanted = collectWantedVersions([
             ...otherStrategies,
             ...nextStrategies.map((s) => ({ name: s.name, units: s.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, strategy_analyze_1.uniq)(nextStrategies.flatMap((s) => s.units.map((u) => u.ref)));
-        (0, strategy_analyze_1.ensureNoInstalledVersionConflicts)(installed, refs);
+        const refs = uniq(nextStrategies.flatMap((s) => s.units.map((u) => u.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);
+            writeJsonAtomic(this.getStrategyPath(s.name), s.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 pinned = parsePinnedSpec(u.ref);
             const v = installed[pinned.name];
             if (!v) {
                 throw new Error(`Unit package is not installed: ${pinned.name}`);
@@ -257,17 +255,17 @@ class StrategyService {
             const nextRef = `${pinned.name}@${v}`;
             return u.args.length === 0 ? nextRef : { ref: nextRef, args: u.args };
         });
-        const others = (0, strategy_config_1.listStrategyNamesFromConfig)(config)
+        const others = 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)([
+            .map((n) => ({ name: n, units: normalizeStrategyUnits(this.readStrategy(n)) }));
+        const nextWanted = collectWantedVersions([
             ...others,
             {
                 name,
                 units: pinnedUnits.map((x) => typeof x === "string" ? { ref: x, args: [] } : { ref: x.ref, args: x.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.`);
         }
@@ -278,23 +276,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))
+            units: normalizeStrategyUnits(this.readStrategy(n))
         }));
-        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 }))
+            .map((s) => computeDrift({ strategyName: s.name, units: s.units, installed }))
             .filter((d) => d.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 { installPinnedPackage, updatePackageToLatest } from "../user-packages/user-package-installer.js";
+import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.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,10 @@
-"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) => {
+export const isUnitLike = (value) => {
     if (!isRecord(value)) {
         return false;
     }
@@ -25,4 +22,22 @@ 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((v) => typeof v === "function" && v.name?.endsWith("Unit"));
+    if (typeof fallback === "function") {
+        return fallback;
+    }
+    return undefined;
+};

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

@@ -1,18 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePinnedSpec = void 0;
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 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) => {
+export const parsePinnedSpec = (input) => {
     const trimmed = input.trim();
     if (!trimmed) {
         throw new Error("package spec is empty");
     }
-    const npa = require("npm-package-arg");
+    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)) {
         throw new Error(`Invalid package spec: ${trimmed}`);
@@ -34,4 +35,3 @@ const parsePinnedSpec = (input) => {
     }
     return { name, version: rawSpec, spec: `${name}@${rawSpec}` };
 };
-exports.parsePinnedSpec = parsePinnedSpec;