@pagepocket/cli 0.12.0 → 0.14.5

package/dist/commands/archive.js

@@ -1,139 +1,12 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
 import { Args, Command, Flags } from "@oclif/core";
 import { ga, ns, PagePocket } from "@pagepocket/lib";
 import chalk from "chalk";
+import ora from "ora";
 import { ConfigService } from "../services/config-service.js";
 import { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
-import { readBuiltinStrategy, listBuiltinStrategyNames } from "../services/strategy/builtin-strategy-registry.js";
-import { normalizeStrategyUnits } from "../services/strategy/strategy-normalize.js";
 import { StrategyService } from "../services/strategy/strategy-service.js";
-import { UnitStore } from "../services/units/unit-store.js";
-import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
-import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
-import { uniq } from "../utils/array.js";
-import { withSpinner } from "../utils/with-spinner.js";
-const buildMissingStrategyError = (input) => {
-    const available = uniq([...input.installedNames, ...listBuiltinStrategyNames()])
-        .filter((name) => name.trim().length > 0)
-        .sort((left, right) => left.localeCompare(right));
-    const suffix = available.length > 0
-        ? ` Available strategies: ${available.join(", ")}`
-        : " No strategies found.";
-    return new Error(`Strategy not found: ${input.strategyName}.${suffix}`);
-};
-const resolveStrategy = (input) => {
-    const installedNames = input.strategyService.listInstalledStrategyNames();
-    if (installedNames.includes(input.strategyName)) {
-        return {
-            name: input.strategyName,
-            strategyFile: input.strategyService.readStrategy(input.strategyName),
-            source: "installed"
-        };
-    }
-    const builtin = readBuiltinStrategy(input.strategyName);
-    if (builtin) {
-        return {
-            name: input.strategyName,
-            strategyFile: builtin,
-            source: "builtin"
-        };
-    }
-    throw buildMissingStrategyError({
-        strategyName: input.strategyName,
-        installedNames
-    });
-};
-const assertNoDuplicateUnitIds = (input) => {
-    const seen = new Set();
-    const duplicateUnit = input.units.find((unit) => {
-        if (seen.has(unit.id)) {
-            return true;
-        }
-        seen.add(unit.id);
-        return false;
-    });
-    if (duplicateUnit) {
-        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${duplicateUnit.id}`);
-    }
-};
-const loadInstalledStrategyUnits = async (input) => {
-    const strategyService = new StrategyService(input.configService);
-    const unitStore = new UnitStore(input.configService);
-    strategyService.ensureConfigFileExists();
-    const strategyFile = strategyService.readStrategy(input.strategyName);
-    const normalized = normalizeStrategyUnits(strategyFile);
-    const installed = unitStore.readInstalledDependencyVersions();
-    const drift = normalized.flatMap((unit) => {
-        const pinned = parsePinnedSpec(unit.ref);
-        const installedVersion = installed[pinned.name];
-        if (!installedVersion || installedVersion !== pinned.version) {
-            return [
-                {
-                    name: pinned.name,
-                    pinned: pinned.version,
-                    installed: installedVersion
-                }
-            ];
-        }
-        return [];
-    });
-    if (drift.length > 0) {
-        const details = drift
-            .map((driftItem) => {
-            const installedText = typeof driftItem.installed === "string" ? driftItem.installed : "(not installed)";
-            return `${driftItem.name}: pinned ${driftItem.pinned}, installed ${installedText}`;
-        })
-            .join("; ");
-        throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
-            `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
-    }
-    const units = await Promise.all(normalized.map(async (unit) => unitStore.instantiateFromRef(unit.ref, unit.args)));
-    assertNoDuplicateUnitIds({
-        strategyName: input.strategyName,
-        units
-    });
-    return units;
-};
-const instantiateBuiltinUnit = async (input) => {
-    const req = createRequire(import.meta.url);
-    const pinned = parsePinnedSpec(input.ref);
-    const resolved = req.resolve(pinned.name);
-    const mod = (await import(pathToFileURL(resolved).href));
-    const ctor = resolveUnitConstructor(mod);
-    if (!ctor) {
-        throw new Error(`Unit ${pinned.name} does not export a Unit constructor.`);
-    }
-    const instance = new ctor(...input.args);
-    if (!isUnitLike(instance)) {
-        throw new Error(`Unit ${pinned.name} exported constructor did not produce a Unit.`);
-    }
-    return instance;
-};
-const loadBuiltinStrategyUnits = async (input) => {
-    const normalized = normalizeStrategyUnits(input.strategyFile);
-    const units = await Promise.all(normalized.map(async (unit) => instantiateBuiltinUnit({
-        ref: unit.ref,
-        args: unit.args
-    })));
-    assertNoDuplicateUnitIds({
-        strategyName: input.strategyName,
-        units
-    });
-    return units;
-};
-const loadStrategyUnits = async (input) => {
-    if (input.strategy.source === "installed") {
-        return loadInstalledStrategyUnits({
-            strategyName: input.strategy.name,
-            configService: input.configService
-        });
-    }
-    return loadBuiltinStrategyUnits({
-        strategyName: input.strategy.name,
-        strategyFile: input.strategy.strategyFile
-    });
-};
+import { loadStrategyUnits, resolveStrategy } from "../utils/archive-strategy.js";
+import { parseEnvVars, resolveStrategyVars } from "../utils/strategy-vars.js";
 export default class ArchiveCommand extends Command {
     static description = "Archive a web page as an offline snapshot.";
     static args = {
@@ -146,57 +19,66 @@ export default class ArchiveCommand extends Command {
         help: Flags.help({
             char: "h"
         }),
-        timeout: Flags.integer({
-            char: "t",
-            description: "Network idle duration in milliseconds before capture stops",
-            required: false
-        }),
-        maxDuration: Flags.integer({
-            description: "Hard max capture duration in milliseconds",
-            required: false
-        }),
         strategy: Flags.string({
             description: "Run an installed or built-in strategy (unit pipeline) by name"
+        }),
+        env: Flags.string({
+            char: "e",
+            description: "Strategy variable in key:value format (e.g. -e \"timeout:3000\")",
+            multiple: true
         })
     };
     async run() {
         const { args, flags } = await this.parse(ArchiveCommand);
         const targetUrl = args.url;
-        const timeoutMs = typeof flags.timeout === "number" ? flags.timeout : undefined;
-        const maxDurationMs = typeof flags.maxDuration === "number" ? flags.maxDuration : undefined;
         const strategyName = typeof flags.strategy === "string" ? flags.strategy.trim() : undefined;
+        const configService = new ConfigService();
+        const name = strategyName && strategyName.length > 0 ? strategyName : "default";
+        const strategyService = new StrategyService(configService);
+        strategyService.ensureConfigFileExists();
+        const strategy = resolveStrategy({ strategyName: name, strategyService });
+        const envVars = parseEnvVars(flags.env ?? []);
+        const resolvedStrategyFile = resolveStrategyVars(strategy.strategyFile, envVars);
+        const resolvedStrategy = { ...strategy, strategyFile: resolvedStrategyFile };
+        const units = await loadStrategyUnits({ strategy: resolvedStrategy, configService });
+        const captureOptions = resolvedStrategy.strategyFile.pipeline.captureOptions;
         const pagepocket = PagePocket.fromURL(targetUrl);
-        const result = await withSpinner(async (spinner) => {
-            {
-                const configService = new ConfigService();
-                const name = strategyName && strategyName.length > 0 ? strategyName : "default";
-                const strategyService = new StrategyService(configService);
-                strategyService.ensureConfigFileExists();
-                const strategy = resolveStrategy({
-                    strategyName: name,
-                    strategyService
-                });
-                const units = await loadStrategyUnits({
-                    strategy,
-                    configService
-                });
-                const entryTarget = pagepocket;
-                const strategyFile = strategy.strategyFile;
-                const captureOptions = strategyFile.pipeline.captureOptions;
-                const effectiveTimeoutMs = typeof timeoutMs === "number" ? timeoutMs : captureOptions?.timeoutMs;
-                const effectiveMaxDurationMs = typeof maxDurationMs === "number" ? maxDurationMs : captureOptions?.maxDurationMs;
-                const result = await entryTarget.capture({
-                    ...(typeof effectiveTimeoutMs === "number" ? { timeoutMs: effectiveTimeoutMs } : {}),
-                    ...(typeof effectiveMaxDurationMs === "number"
-                        ? { maxDurationMs: effectiveMaxDurationMs }
-                        : {}),
-                    blacklist: [...ga, ...ns],
-                    units,
-                    plugins: await loadConfiguredPlugins().catch(() => [])
-                });
-                return result;
+        let spinner = ora();
+        let activeUnitId = "";
+        let activeUnitLabel = "";
+        const formatUnitLabel = (index, total, unitDescription) => `[${index + 1}/${total}] ${unitDescription}`;
+        pagepocket.on("unit:start", (e) => {
+            activeUnitId = e.unitId;
+            activeUnitLabel = formatUnitLabel(e.index, e.total, e.unitDescription);
+            spinner = ora(activeUnitLabel).start();
+        });
+        pagepocket.on("unit:log", (e) => {
+            if (e.unitId !== activeUnitId) {
+                return;
             }
-        }, "Freezing page");
+            spinner.text = `${activeUnitLabel} ${chalk.gray(e.message)}`;
+        });
+        pagepocket.on("unit:end", (e) => {
+            spinner.succeed(formatUnitLabel(e.index, e.total, e.unitDescription));
+        });
+        let result;
+        try {
+            result = await pagepocket.capture({
+                ...(typeof captureOptions?.timeoutMs === "number"
+                    ? { timeoutMs: captureOptions.timeoutMs }
+                    : {}),
+                ...(typeof captureOptions?.maxDurationMs === "number"
+                    ? { maxDurationMs: captureOptions.maxDurationMs }
+                    : {}),
+                blacklist: [...ga, ...ns],
+                units,
+                plugins: await loadConfiguredPlugins()
+            });
+        }
+        catch (error) {
+            spinner.fail();
+            throw error;
+        }
         this.log(chalk.green("All done! Snapshot created."));
         if (result.kind === "zip") {
             this.log(`Snapshot saved to ${chalk.cyan(result.zip.outputPath)}`);

package/dist/commands/strategy/ls.js

@@ -1,14 +1,19 @@
 import { Command } from "@oclif/core";
 import chalk from "chalk";
 import { listBuiltinStrategyNames, readBuiltinStrategy } from "../../services/strategy/builtin-strategy-registry.js";
-import { normalizeStrategyUnits } from "../../services/strategy/strategy-normalize.js";
+import { normalizeBuiltinStrategyUnits, normalizeStrategyUnits } from "../../services/strategy/strategy-normalize.js";
 import { StrategyService } from "../../services/strategy/strategy-service.js";
 import { uniq } from "../../utils/array.js";
-const formatStrategy = (name, strategyFile) => {
+const formatInstalledStrategy = (name, strategyFile) => {
     const units = normalizeStrategyUnits(strategyFile);
     const pipeline = units.map((unit) => unit.ref).join(" -> ");
     return pipeline.length > 0 ? `${name}${chalk.dim(`(${pipeline})`)}` : name;
 };
+const formatBuiltinStrategy = (name, strategyFile) => {
+    const units = normalizeBuiltinStrategyUnits(strategyFile);
+    const pipeline = units.map((unit) => unit.name).join(" -> ");
+    return pipeline.length > 0 ? `${name}${chalk.dim(`(${pipeline})`)}` : name;
+};
 export default class StrategyLsCommand extends Command {
     static description = "List available strategies.";
     async run() {
@@ -25,11 +30,13 @@ export default class StrategyLsCommand extends Command {
             return;
         }
         for (const name of names) {
-            const strategyFile = installedNames.includes(name)
-                ? service.readStrategy(name)
-                : readBuiltinStrategy(name);
+            const isInstalled = installedNames.includes(name);
+            const strategyFile = isInstalled ? service.readStrategy(name) : readBuiltinStrategy(name);
             if (strategyFile) {
-                this.log(formatStrategy(name, strategyFile));
+                const formatted = isInstalled
+                    ? formatInstalledStrategy(name, strategyFile)
+                    : formatBuiltinStrategy(name, strategyFile);
+                this.log(formatted);
             }
             else {
                 this.log(name);

package/dist/commands/view.js

@@ -51,7 +51,7 @@ export default class ViewCommand extends Command {
             host: flags.host,
             port
         });
-        this.log(`Serving ${chalk.cyan(rootDir)}`);
+        this.log(`Serving ${chalk.cyan(rootDir)} ${chalk.dim(`(${server.snapshotType})`)}`);
         this.log(chalk.green(server.url));
     }
 }

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { execute } from "@oclif/core";
 import { normalizeArgv } from "./utils/normalize-argv.js";
 await execute({

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

@@ -43,3 +43,41 @@ export const normalizeStrategyUnits = (strategy) => {
     const units = strategy.pipeline.units;
     return units.map((spec, idx) => normalizeUnitSpec(spec, idx));
 };
+const parsePackageName = (spec) => {
+    const trimmed = spec.trim();
+    if (trimmed.startsWith("@")) {
+        const afterScope = trimmed.indexOf("/");
+        if (afterScope === -1) {
+            throw new Error(`Invalid scoped package spec: ${trimmed}`);
+        }
+        const versionSep = trimmed.indexOf("@", afterScope + 1);
+        return versionSep === -1 ? trimmed : trimmed.slice(0, versionSep);
+    }
+    const versionSep = trimmed.indexOf("@");
+    return versionSep === -1 ? trimmed : trimmed.slice(0, versionSep);
+};
+const normalizeBuiltinUnitSpec = (spec, idx) => {
+    if (typeof spec === "string") {
+        return { name: parsePackageName(spec), args: [] };
+    }
+    if (!isRecord(spec)) {
+        throw new Error(`Invalid unit spec at index ${idx}`);
+    }
+    const ref = spec.ref;
+    if (typeof ref !== "string") {
+        throw new Error(`Invalid unit ref at index ${idx}`);
+    }
+    const argsRaw = spec.args;
+    const args = typeof argsRaw === "undefined" ? [] : argsRaw;
+    if (!Array.isArray(args)) {
+        throw new Error(`Invalid unit args at index ${idx} (must be an array)`);
+    }
+    if (!isJsonValue(args)) {
+        throw new Error(`Invalid unit args at index ${idx} (must be JSON-only)`);
+    }
+    return { name: parsePackageName(ref), args };
+};
+export const normalizeBuiltinStrategyUnits = (strategy) => {
+    const units = strategy.pipeline.units;
+    return units.map((spec, idx) => normalizeBuiltinUnitSpec(spec, idx));
+};

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

@@ -1,7 +1,6 @@
 import path from "node:path";
 import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
-import { installPinnedPackage } from "../user-packages/user-package-installer.js";
-import { updatePackageToLatest } from "../user-packages/user-package-installer.js";
+import { installPinnedPackage, updatePackageToLatest } from "../user-packages/user-package-installer.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";

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

@@ -7,9 +7,6 @@ export const isUnitLike = (value) => {
     if (typeof value.id !== "string" || value.id.trim().length === 0) {
         return false;
     }
-    if (typeof value.kind !== "string" || value.kind.trim().length === 0) {
-        return false;
-    }
     if (!isCallable(value.run)) {
         return false;
     }

package/dist/units/network-observer-unit.js

@@ -7,7 +7,7 @@ import { Unit } from "@pagepocket/lib";
  */
 export class NetworkObserverUnit extends Unit {
     id = "networkObserver";
-    kind = "observe.network";
+    description = "Observing network events";
     config;
     constructor(config = {}) {
         super();

package/dist/utils/archive-strategy.js

@@ -0,0 +1,138 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { readBuiltinStrategy, listBuiltinStrategyNames } from "../services/strategy/builtin-strategy-registry.js";
+import { normalizeBuiltinStrategyUnits, normalizeStrategyUnits } from "../services/strategy/strategy-normalize.js";
+import { StrategyService } from "../services/strategy/strategy-service.js";
+import { UnitStore } from "../services/units/unit-store.js";
+import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
+import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
+import { uniq } from "./array.js";
+const buildMissingStrategyError = (input) => {
+    const available = uniq([...input.installedNames, ...listBuiltinStrategyNames()])
+        .filter((name) => name.trim().length > 0)
+        .sort((left, right) => left.localeCompare(right));
+    const suffix = available.length > 0
+        ? ` Available strategies: ${available.join(", ")}`
+        : " No strategies found.";
+    return new Error(`Strategy not found: ${input.strategyName}.${suffix}`);
+};
+const assertNoDuplicateUnitIds = (input) => {
+    const seen = new Set();
+    const duplicateUnit = input.units.find((unit) => {
+        if (seen.has(unit.id)) {
+            return true;
+        }
+        seen.add(unit.id);
+        return false;
+    });
+    if (duplicateUnit) {
+        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${duplicateUnit.id}`);
+    }
+};
+const loadInstalledStrategyUnits = async (input) => {
+    const strategyService = new StrategyService(input.configService);
+    const unitStore = new UnitStore(input.configService);
+    strategyService.ensureConfigFileExists();
+    const strategyFile = strategyService.readStrategy(input.strategyName);
+    const normalized = normalizeStrategyUnits(strategyFile);
+    const installed = unitStore.readInstalledDependencyVersions();
+    const drift = normalized.flatMap((unit) => {
+        const pinned = parsePinnedSpec(unit.ref);
+        const installedVersion = installed[pinned.name];
+        if (!installedVersion || installedVersion !== pinned.version) {
+            return [
+                {
+                    name: pinned.name,
+                    pinned: pinned.version,
+                    installed: installedVersion
+                }
+            ];
+        }
+        return [];
+    });
+    if (drift.length > 0) {
+        const details = drift
+            .map((driftItem) => {
+            const installedText = typeof driftItem.installed === "string" ? driftItem.installed : "(not installed)";
+            return `${driftItem.name}: pinned ${driftItem.pinned}, installed ${installedText}`;
+        })
+            .join("; ");
+        throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
+            `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
+    }
+    const units = await Promise.all(normalized.map(async (unit) => unitStore.instantiateFromRef(unit.ref, unit.args)));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
+    });
+    return units;
+};
+const instantiateBuiltinUnit = async (input) => {
+    const req = createRequire(import.meta.url);
+    const resolved = req.resolve(input.name);
+    const mod = (await import(pathToFileURL(resolved).href));
+    const ctor = resolveUnitConstructor(mod);
+    if (!ctor) {
+        throw new Error(`Unit ${input.name} does not export a Unit constructor.`);
+    }
+    const instance = new ctor(...input.args);
+    if (!isUnitLike(instance)) {
+        throw new Error(`Unit ${input.name} exported constructor did not produce a Unit.`);
+    }
+    return instance;
+};
+const loadBuiltinStrategyUnits = async (input) => {
+    const normalized = normalizeBuiltinStrategyUnits(input.strategyFile);
+    const units = await Promise.all(normalized.map(async (unit) => instantiateBuiltinUnit(unit)));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
+    });
+    return units;
+};
+/**
+ * Resolve strategy by name from installed strategies first, then built-in strategies.
+ *
+ * Usage:
+ * const strategy = resolveStrategy({ strategyName: "default", strategyService });
+ */
+export const resolveStrategy = (input) => {
+    const installedNames = input.strategyService.listInstalledStrategyNames();
+    if (installedNames.includes(input.strategyName)) {
+        return {
+            name: input.strategyName,
+            strategyFile: input.strategyService.readStrategy(input.strategyName),
+            source: "installed"
+        };
+    }
+    const builtin = readBuiltinStrategy(input.strategyName);
+    if (builtin) {
+        return {
+            name: input.strategyName,
+            strategyFile: builtin,
+            source: "builtin"
+        };
+    }
+    throw buildMissingStrategyError({
+        strategyName: input.strategyName,
+        installedNames
+    });
+};
+/**
+ * Load executable unit instances for a resolved strategy.
+ *
+ * Usage:
+ * const units = await loadStrategyUnits({ strategy, configService });
+ */
+export const loadStrategyUnits = async (input) => {
+    if (input.strategy.source === "installed") {
+        return loadInstalledStrategyUnits({
+            strategyName: input.strategy.name,
+            configService: input.configService
+        });
+    }
+    return loadBuiltinStrategyUnits({
+        strategyName: input.strategy.name,
+        strategyFile: input.strategy.strategyFile
+    });
+};

package/dist/utils/strategy-vars.js

@@ -0,0 +1,117 @@
+const VAR_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)(?::([^}]*))?\}\}/g;
+/**
+ * Parse `-e` flag values into a typed variable map.
+ *
+ * Each raw arg must be in `key:value` format. The key is the variable name,
+ * everything after the first colon is the raw value string.
+ *
+ * Value type inference:
+ * - Parseable as finite number → number
+ * - `"true"` / `"false"` → boolean
+ * - Otherwise → string
+ *
+ * Usage:
+ *   parseEnvVars(["timeout:3000", "overwrite:true", "outDir:./snapshots"])
+ *   // => { timeout: 3000, overwrite: true, outDir: "./snapshots" }
+ */
+export const parseEnvVars = (rawArgs) => {
+    const vars = {};
+    for (const raw of rawArgs) {
+        const colonIndex = raw.indexOf(":");
+        if (colonIndex === -1) {
+            throw new Error(`Invalid -e value: "${raw}". Expected format: key:value (e.g. -e "timeout:3000")`);
+        }
+        const key = raw.slice(0, colonIndex).trim();
+        const valueRaw = raw.slice(colonIndex + 1);
+        if (key.length === 0) {
+            throw new Error(`Invalid -e value: "${raw}". Key must not be empty.`);
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+            throw new Error(`Invalid variable name: "${key}". Must be a valid identifier (letters, digits, underscores).`);
+        }
+        if (key in vars) {
+            throw new Error(`Duplicate variable: "${key}". Each variable can only be specified once.`);
+        }
+        vars[key] = inferValue(valueRaw);
+    }
+    return vars;
+};
+const inferValue = (raw) => {
+    const asNumber = Number(raw);
+    if (raw.length > 0 && Number.isFinite(asNumber)) {
+        return asNumber;
+    }
+    if (raw === "true") {
+        return true;
+    }
+    if (raw === "false") {
+        return false;
+    }
+    return raw;
+};
+/**
+ * Recursively resolve `{{varName}}` and `{{varName:default}}` placeholders in a JSON structure.
+ *
+ * - Only string values are scanned for placeholders.
+ * - `{{var:default}}` provides an inline default; the default is type-inferred the same way as `-e` values.
+ * - If the entire string is a single `{{var}}` or `{{var:default}}`, the value is replaced with the
+ *   variable's typed value (number, boolean, or string).
+ * - If the string contains mixed text and placeholders (e.g. `"path/{{name}}"`),
+ *   all placeholders are interpolated and the result remains a string.
+ * - Throws if any referenced variable has no `-e` value AND no inline default.
+ *
+ * Usage:
+ *   resolveStrategyVars({ timeoutMs: "{{timeout:5000}}" }, {})
+ *   // => { timeoutMs: 5000 }
+ */
+export const resolveStrategyVars = (json, vars) => {
+    const defaults = new Map();
+    const referenced = new Set();
+    const resolved = resolveNode(json, vars, defaults, referenced);
+    const missing = [...referenced].filter((name) => !(name in vars) && !defaults.has(name));
+    if (missing.length > 0) {
+        throw new Error(`Missing strategy variable(s): ${missing.join(", ")}. ` +
+            `Pass them with ${missing.map((name) => `-e "${name}:<value>"`).join(" ")}`);
+    }
+    return resolved;
+};
+const resolveNode = (node, vars, defaults, referenced) => {
+    if (typeof node === "string") {
+        return resolveString(node, vars, defaults, referenced);
+    }
+    if (Array.isArray(node)) {
+        return node.map((item) => resolveNode(item, vars, defaults, referenced));
+    }
+    if (isRecord(node)) {
+        const result = {};
+        for (const [key, value] of Object.entries(node)) {
+            result[key] = resolveNode(value, vars, defaults, referenced);
+        }
+        return result;
+    }
+    return node;
+};
+const resolveString = (value, vars, defaults, referenced) => {
+    const matches = [...value.matchAll(VAR_PATTERN)];
+    if (matches.length === 0) {
+        return value;
+    }
+    for (const match of matches) {
+        const varName = match[1];
+        const rawDefault = match[2];
+        referenced.add(varName);
+        if (rawDefault !== undefined && !defaults.has(varName)) {
+            defaults.set(varName, inferValue(rawDefault));
+        }
+    }
+    const isSingleWholeVar = matches.length === 1 && matches[0][0] === value;
+    if (isSingleWholeVar) {
+        const varName = matches[0][1];
+        return vars[varName] ?? defaults.get(varName);
+    }
+    return value.replace(VAR_PATTERN, (_match, varName) => {
+        const resolved = vars[varName] ?? defaults.get(varName);
+        return String(resolved ?? "");
+    });
+};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);