@synopackageland/cli 0.5.3 → 0.6.1

package/dist/standalone/inspect-helper.js

@@ -1,103 +0,0 @@
-import { bootstrapOps } from "./authorization.js";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import * as tar from "tar";
-import { windowScriptName } from "./dsm-window.js";
-import { helperOps } from "./helper.js";
-import { sha256 } from "./helper-inventory.js";
-import { renderStandaloneScript } from "./lifecycle.js";
-import { rootTasks } from "./root-window.js";
-import { decodeSDKRegistry } from "./worker-registry.js";
-/** Artifact consistency only; bytes, approval and health never certify NAS access. */
-export async function inspectHelper(dir, info, findings, daemon = false) {
-    const files = new Map();
-    const windowPath = `ui/${windowScriptName({ build: Number(info.version?.split("-").at(-1)) })}`;
-    const windows = [];
-    let oversized = false;
-    await tar.t({ file: join(dir, "package.tgz"), onReadEntry(entry) {
-            const path = entry.path.replace(/^\.\//, "");
-            // Enumerate candidates to reject extras; only the INFO-derived exact path is read.
-            if (/^ui\/window-[^/]*\.js$/.test(path))
-                windows.push(path);
-            if (entry.type !== "File" || !(path.startsWith("integration/workers/") || ["authorization/manifest.json", "integration/helper", "integration/inventory.json", "integration/workers.json", "ui/cgi/api.cgi", windowPath].includes(path)))
-                return;
-            const limit = ["integration/helper", "ui/cgi/api.cgi"].includes(path) ? 64 * 1024 * 1024 : 1024 * 1024;
-            if (files.has(path) || entry.size > limit) {
-                oversized = true;
-                return;
-            }
-            const chunks = [];
-            let size = 0;
-            entry.on("data", (chunk) => { size += chunk.length; if (size <= limit)
-                chunks.push(chunk);
-            else
-                oversized = true; });
-            entry.on("end", () => files.set(path, Buffer.concat(chunks)));
-        } });
-    try {
-        if (oversized)
-            throw new Error("oversized/duplicate payload");
-        const bytes = (path) => { const b = files.get(path); if (!b)
-            throw new Error(`missing ${path}`); return b; };
-        const raw = bytes("integration/inventory.json").toString("utf8");
-        const i = JSON.parse(raw);
-        const keys = i.dataAccess === undefined ? "package,payloadDigest,protocol,registryDigest,version" : "dataAccess,package,payloadDigest,protocol,registryDigest,version";
-        if (Object.keys(i).sort().join(",") !== keys || (i.dataAccess !== undefined && (i.protocol !== 2 || !["unavailable", "relaxed"].includes(i.dataAccess))) ||
-            i.package !== info.package || i.version !== info.version || !/^[A-Za-z][A-Za-z0-9]{1,63}$/.test(i.package) || !/^\d+(\.\d+){0,3}-\d{4}$/.test(i.version) || ![1, 2].includes(i.protocol) ||
-            !/^[a-f0-9]{64}$/.test(i.payloadDigest) || !/^[a-f0-9]{64}$/.test(i.registryDigest) || JSON.stringify(i) !== raw)
-            throw new Error("invalid inventory");
-        if (windows.length !== 1 || windows[0] !== windowPath)
-            throw new Error("missing/ambiguous window or build mismatch");
-        const helper = bytes("integration/helper");
-        if (sha256(helper) !== i.payloadDigest || !helper.includes(Buffer.from(JSON.stringify({ ...i, payloadDigest: "" }))) ||
-            !bytes("ui/cgi/api.cgi").includes(Buffer.from(raw)))
-            throw new Error("payload/compiled inventory mismatch");
-        const workers = bytes("integration/workers.json");
-        const rawRegistry = JSON.parse(workers.toString("utf8"));
-        const sdkRegistry = !Array.isArray(rawRegistry);
-        const registry = sdkRegistry ? decodeSDKRegistry(workers).inert : rawRegistry;
-        if (sdkRegistry && (i.protocol !== 2 || i.dataAccess !== "relaxed" || !helper.includes(workers)))
-            throw new Error("compiled SDK registry mismatch");
-        if (!Array.isArray(registry) || registry.length > 16 || sha256(workers) !== i.registryDigest || (!sdkRegistry && JSON.stringify(registry) !== workers.toString("utf8")))
-            throw new Error("invalid registry");
-        let previous = "", total = 0;
-        for (const worker of registry) {
-            if (!worker || Object.keys(worker).sort().join(",") !== "digest,id" || typeof worker.id !== "string" ||
-                !/^[a-z][a-z0-9_]{0,31}$/.test(worker.id) || (previous && (sdkRegistry ? previous >= worker.id : previous.localeCompare(worker.id, "en") >= 0)) ||
-                !/^[a-f0-9]{64}$/.test(worker.digest))
-                throw new Error("invalid worker");
-            const content = bytes(`integration/workers/${worker.id}`);
-            total += content.length;
-            if (total > 1024 * 1024 || sha256(content) !== worker.digest)
-                throw new Error("worker digest mismatch");
-            previous = worker.id;
-        }
-        if ([...files.keys()].filter(p => p.startsWith("integration/workers/")).length !== registry.length)
-            throw new Error("unregistered worker");
-        const manifest = { package: i.package, spkVersion: i.version, privilege: "root", integration: { protocol: i.protocol, workers: {} } };
-        const tasks = JSON.parse(/\.rootTasks = (\[[^\n]+\]);/.exec(bytes(windowPath).toString("utf8"))?.[1] ?? "null");
-        const originalOps = helperOps(manifest, i);
-        let expected = rootTasks({ ...manifest, rootOps: originalOps });
-        // Existing CLI 0.5 archives have inline hash-pinned helper tasks. New
-        // bootstrap archives carry an additional independently inspected inventory.
-        if (files.has("authorization/manifest.json")) {
-            const plan = JSON.parse(bytes("authorization/manifest.json").toString("utf8"));
-            if (JSON.stringify(plan.inventory.operations.filter((op) => op.name.startsWith("helper_"))) !== JSON.stringify(originalOps))
-                throw new Error("bootstrap helper binding mismatch");
-            expected = rootTasks({ ...manifest, rootOps: bootstrapOps({ ...manifest, rootOps: originalOps }, plan.bootstrapSha256) });
-        }
-        if (!Array.isArray(tasks) || JSON.stringify(tasks.filter(t => t.op?.startsWith("helper_"))) !== JSON.stringify(expected))
-            throw new Error("approved task mismatch");
-        // Daemon lifecycle is verified separately with the complete daemon config.
-        if (!daemon)
-            for (const hook of ["start-stop-status", "preupgrade", "preuninst"]) {
-                if (readFileSync(join(dir, "scripts", hook), "utf8") !== renderStandaloneScript(hook, manifest))
-                    throw new Error("lifecycle mismatch");
-            }
-        return { protocol: i.protocol, dataAccess: i.dataAccess ?? "unavailable" };
-    }
-    catch {
-        findings.push("integration inventory、digest、compiled binding、worker 或 lifecycle 不符合固定契約");
-        return undefined;
-    }
-}

package/dist/standalone/job-diagnostics.d.ts

@@ -1 +0,0 @@
-export declare function formatJobDiagnostic(raw: string | Uint8Array): string;

package/dist/standalone/job-diagnostics.js

@@ -1,49 +0,0 @@
-import { strictJSON } from './worker-contract-json.js';
-const WORKER_SAFE_REASONS = ['invalid-request', 'incompatible', 'unsupported', 'replay', 'stale', 'expired', 'denied', 'unavailable', 'suspended', 'revoked', 'fenced', 'busy', 'limit-exceeded', 'canceled', 'timeout', 'partial', 'commit-uncertain', 'cleanup-required', 'internal'];
-// S5 formatter only: no command registration, network, SSH or raw-log reader.
-// Reject the whole projection on schema/serializer failure; never echo input.
-export function formatJobDiagnostic(raw) {
-    try {
-        const record = (value, required, optional = []) => {
-            if (!value || typeof value !== 'object' || Array.isArray(value))
-                throw 0;
-            const o = value;
-            if (required.some(k => !Object.hasOwn(o, k)) || Object.keys(o).some(k => !required.includes(k) && !optional.includes(k)))
-                throw 0;
-            return o;
-        };
-        const d = record(strictJSON(raw, 32768), ['diagnosticSchema', 'availability', 'jobs', 'total', 'truncated']);
-        if (d.diagnosticSchema !== 1 || d.availability !== 'unavailable' || !Array.isArray(d.jobs) || d.jobs.length > 10 || !Number.isSafeInteger(d.total) || d.total < d.jobs.length || d.total > 256 || typeof d.truncated !== 'boolean' || d.truncated !== (d.total > d.jobs.length))
-            throw 0;
-        const aliases = new Set();
-        const jobs = d.jobs.map(value => {
-            const j = record(value, ['alias', 'state', 'cancelRequested', 'drained', 'effectsUnknown'], ['safeReason']);
-            if (typeof j.alias !== 'string' || !/^[a-f0-9]{64}$/.test(j.alias) || !['pending', 'running', 'cancel-requested', 'draining', 'succeeded', 'failed', 'canceled', 'interrupted', 'cleanup-required'].includes(j.state))
-                throw 0;
-            if (['cancelRequested', 'drained', 'effectsUnknown'].some(k => typeof j[k] !== 'boolean'))
-                throw 0;
-            if (j.safeReason !== undefined && !WORKER_SAFE_REASONS.includes(j.safeReason))
-                throw 0;
-            if (aliases.has(j.alias))
-                throw 0;
-            aliases.add(j.alias);
-            if (j.state === 'succeeded' && (!j.drained || j.cancelRequested || j.effectsUnknown || j.safeReason !== undefined))
-                throw 0;
-            if (['pending', 'running'].includes(j.state) && (j.drained || j.cancelRequested))
-                throw 0;
-            if (['cancel-requested', 'draining'].includes(j.state) && (!j.cancelRequested || j.drained))
-                throw 0;
-            if (j.state === 'cleanup-required' && (j.drained || j.safeReason !== 'cleanup-required'))
-                throw 0;
-            if (['failed', 'interrupted', 'canceled'].includes(j.state) && j.safeReason === undefined)
-                throw 0;
-            if (j.state === 'canceled' && !j.cancelRequested)
-                throw 0;
-            return { alias: j.alias, state: j.state, ...(j.safeReason === undefined ? {} : { safeReason: j.safeReason }), cancelRequested: j.cancelRequested, drained: j.drained, effectsUnknown: j.effectsUnknown };
-        });
-        return JSON.stringify({ diagnosticSchema: 1, availability: 'unavailable', jobs, total: d.total, truncated: d.truncated }) + '\n';
-    }
-    catch {
-        return '{"safeReason":"invalid-request"}\n';
-    }
-}

package/dist/standalone/lifecycle-helper.d.ts

@@ -1,2 +0,0 @@
-/** Non-privileged management veto shared by the generated package hooks. */
-export declare function renderHelperStoppedCheck(packageId: string, revoke?: boolean): string;

package/dist/standalone/lifecycle-helper.js

@@ -1,12 +0,0 @@
-/** Non-privileged management veto shared by the generated package hooks. */
-export function renderHelperStoppedCheck(packageId, revoke = false) {
-    return `${revoke ? `/var/packages/${packageId}/target/integration/helper revoke && ` : ''}/var/packages/${packageId}/target/integration/helper check-stopped || {
-  message='Run the approved helper_teardown or helper_disable operation before stopping, upgrading or uninstalling.'
-  printf '%s\\n' "$message" >&2
-  if [ -n "\${SYNOPKG_TEMP_LOGFILE:-}" ]; then
-    (printf '%s\\n' "$message" >> "$SYNOPKG_TEMP_LOGFILE") 2>/dev/null || :
-  fi
-  exit 1
-}
-`;
-}

package/dist/standalone/root-messages.d.ts

@@ -1,7 +0,0 @@
-import type { Catalog, Locale } from "./i18n.js";
-/**
- * Text of the authorization panel every privilege: root package shows, the
- * same in every package. DSM's own words (Task Scheduler, Run, Remove, …) are
- * taken verbatim from DSM 7.4; test/standalone-root-messages.test.ts pins them.
- */
-export declare const ROOT_MESSAGES: Record<Locale, Catalog>;

package/dist/standalone/root-messages.js

@@ -1,259 +0,0 @@
-/**
- * Text of the authorization panel every privilege: root package shows, the
- * same in every package. DSM's own words (Task Scheduler, Run, Remove, …) are
- * taken verbatim from DSM 7.4; test/standalone-root-messages.test.ts pins them.
- */
-export const ROOT_MESSAGES = {
-    en: {
-        title: "Administrator authorization",
-        intro: "This package can run the fixed operation \"{op}\" as root. A DSM administrator approves it once with their password. DSM then keeps it as a disabled task in Task Scheduler that runs only when an administrator clicks Run here.",
-        status: "Status",
-        last_run: "Last run time",
-        never: "Not run yet",
-        output: "Result",
-        "state.checking": "Loading...",
-        "state.missing": "Not authorized",
-        "state.ready": "Authorized",
-        "state.outdated": "The package was updated and needs authorization again",
-        "state.conflict": "Another Task Scheduler task already uses the name \"{name}\"",
-        authorize: "Authorize",
-        run: "Run",
-        remove: "Remove",
-        retry: "Retry",
-        completed: "Completed",
-        cancelled: "Authorization was cancelled. Nothing was created.",
-        admin_only: "Only administrator accounts can perform this operation.",
-        uninstall_hint: "Before uninstalling this package, click Remove to delete its task from Task Scheduler.",
-        "error.root_conflict": "Rename or delete the task \"{name}\" in Task Scheduler, then click Retry.",
-        "error.root_cancelled": "Password confirmation was cancelled. No operation was run.",
-        "error.root_not_ready": "Authorize this operation first.",
-        "error.root_task_failed": "The task ended with an error. Check its history in Task Scheduler, then click Retry.",
-        "error.root_timeout": "The task did not finish in time. Check it in Task Scheduler, then click Retry.",
-        "error.root_verify_failed": "Task Scheduler does not show the expected task. Click Retry.",
-        "error.default": "The operation failed ({code}). Click Retry.",
-    },
-    "zh-TW": {
-        title: "管理員授權",
-        intro: "此套件可用 root 身分執行固定操作「{op}」。DSM 管理員以密碼核准一次後，DSM 會在任務排程表中保留一個已停用的任務，只有管理員在此按下「執行」時才會執行。",
-        status: "狀態",
-        last_run: "最後執行時間",
-        never: "尚未執行",
-        output: "結果",
-        "state.checking": "載入中...",
-        "state.missing": "未授權",
-        "state.ready": "已授權",
-        "state.outdated": "套件已更新，需要重新授權",
-        "state.conflict": "任務排程表中已有其他任務使用名稱「{name}」",
-        authorize: "授權",
-        run: "執行",
-        remove: "移除",
-        retry: "重試",
-        completed: "已完成",
-        cancelled: "已取消授權，未建立任何任務。",
-        admin_only: "僅限管理員帳號允許執行此操作。",
-        uninstall_hint: "解除安裝此套件前，請按「移除」從任務排程表刪除它的任務。",
-        "error.root_conflict": "請在任務排程表中重新命名或刪除任務「{name}」，再按「重試」。",
-        "error.root_cancelled": "已取消密碼確認，未執行任何操作。",
-        "error.root_not_ready": "請先授權此操作。",
-        "error.root_task_failed": "任務執行失敗。請在任務排程表查看其記錄，再按「重試」。",
-        "error.root_timeout": "任務未在時限內完成。請在任務排程表確認後，再按「重試」。",
-        "error.root_verify_failed": "任務排程表中沒有預期的任務。請按「重試」。",
-        "error.default": "操作失敗（{code}）。請按「重試」。",
-    },
-    "zh-CN": {
-        title: "管理员授权",
-        intro: "此套件可以 root 身份运行固定操作“{op}”。DSM 管理员用密码批准一次后，DSM 会在任务计划中保留一个已禁用的任务，只有管理员在此单击“运行”时才会运行。",
-        status: "状态",
-        last_run: "最后运行时间",
-        never: "尚未运行",
-        output: "结果",
-        "state.checking": "加载中...",
-        "state.missing": "未授权",
-        "state.ready": "已授权",
-        "state.outdated": "套件已更新，需要重新授权",
-        "state.conflict": "任务计划中已有其他任务使用名称“{name}”",
-        authorize: "授权",
-        run: "运行",
-        remove: "删除",
-        retry: "重试",
-        completed: "已完成",
-        cancelled: "已取消授权，未创建任何任务。",
-        admin_only: "只有管理员帐户才能执行此操作。",
-        uninstall_hint: "卸载此套件前，请单击“删除”从任务计划中删除它的任务。",
-        "error.root_conflict": "请在任务计划中重命名或删除任务“{name}”，然后单击“重试”。",
-        "error.root_cancelled": "已取消密码确认，未执行任何操作。",
-        "error.root_not_ready": "请先授权此操作。",
-        "error.root_task_failed": "任务运行失败。请在任务计划中查看其记录，然后单击“重试”。",
-        "error.root_timeout": "任务未在时限内完成。请在任务计划中确认后单击“重试”。",
-        "error.root_verify_failed": "任务计划中没有预期的任务。请单击“重试”。",
-        "error.default": "操作失败（{code}）。请单击“重试”。",
-    },
-    ja: {
-        title: "管理者の承認",
-        intro: "このパッケージは固定の操作「{op}」を root として実行できます。DSM 管理者がパスワードで一度承認すると、DSM はタスク スケジューラーに無効のタスクとして保持し、管理者がここで「実行」をクリックしたときだけ実行します。",
-        status: "状態",
-        last_run: "最終実行時刻",
-        never: "まだ実行されていません",
-        output: "結果",
-        "state.checking": "読み込み中...",
-        "state.missing": "未承認",
-        "state.ready": "承認済み",
-        "state.outdated": "パッケージが更新されたため、再承認が必要です",
-        "state.conflict": "タスク スケジューラーの別のタスクが名前「{name}」を使用しています",
-        authorize: "承認",
-        run: "実行",
-        remove: "削除",
-        retry: "再試行",
-        completed: "完了",
-        cancelled: "承認はキャンセルされました。何も作成されていません。",
-        admin_only: "この操作を実行できるのは管理者アカウントのみです。",
-        uninstall_hint: "このパッケージをアンインストールする前に、「削除」をクリックしてタスク スケジューラーからタスクを削除してください。",
-        "error.root_conflict": "タスク スケジューラーでタスク「{name}」の名前を変更するか削除してから、「再試行」をクリックしてください。",
-        "error.root_cancelled": "パスワードの確認がキャンセルされました。操作は実行されていません。",
-        "error.root_not_ready": "先にこの操作を承認してください。",
-        "error.root_task_failed": "タスクがエラーで終了しました。タスク スケジューラーで履歴を確認してから、「再試行」をクリックしてください。",
-        "error.root_timeout": "タスクが時間内に完了しませんでした。タスク スケジューラーで確認してから、「再試行」をクリックしてください。",
-        "error.root_verify_failed": "タスク スケジューラーに想定したタスクが見つかりません。「再試行」をクリックしてください。",
-        "error.default": "操作に失敗しました ({code})。「再試行」をクリックしてください。",
-    },
-    ko: {
-        title: "관리자 승인",
-        intro: "이 패키지는 고정된 작업 \"{op}\"을(를) root로 실행할 수 있습니다. DSM 관리자가 암호로 한 번 승인하면 DSM이 작업 스케줄러에 비활성화된 작업으로 보관하며, 관리자가 여기에서 \"실행\"을 클릭할 때만 실행됩니다.",
-        status: "상태",
-        last_run: "마지막 실행 시간",
-        never: "아직 실행되지 않음",
-        output: "결과",
-        "state.checking": "로드 중…",
-        "state.missing": "승인되지 않음",
-        "state.ready": "승인됨",
-        "state.outdated": "패키지가 업데이트되어 다시 승인해야 합니다",
-        "state.conflict": "작업 스케줄러의 다른 작업이 이미 \"{name}\" 이름을 사용하고 있습니다",
-        authorize: "승인",
-        run: "실행",
-        remove: "제거",
-        retry: "재시도",
-        completed: "완료됨",
-        cancelled: "승인이 취소되었습니다. 아무것도 만들어지지 않았습니다.",
-        admin_only: "관리자 계정에서만 이 작업을 수행할 수 있습니다.",
-        uninstall_hint: "이 패키지를 제거하기 전에 \"제거\"를 클릭하여 작업 스케줄러에서 작업을 삭제하십시오.",
-        "error.root_conflict": "작업 스케줄러에서 작업 \"{name}\"의 이름을 바꾸거나 삭제한 후 \"재시도\"를 클릭하십시오.",
-        "error.root_cancelled": "비밀번호 확인이 취소되었습니다. 작업이 실행되지 않았습니다.",
-        "error.root_not_ready": "먼저 이 작업을 승인하십시오.",
-        "error.root_task_failed": "작업이 오류로 종료되었습니다. 작업 스케줄러에서 기록을 확인한 후 \"재시도\"를 클릭하십시오.",
-        "error.root_timeout": "작업이 제시간에 완료되지 않았습니다. 작업 스케줄러에서 확인한 후 \"재시도\"를 클릭하십시오.",
-        "error.root_verify_failed": "작업 스케줄러에 예상한 작업이 없습니다. \"재시도\"를 클릭하십시오.",
-        "error.default": "작업에 실패했습니다({code}). \"재시도\"를 클릭하십시오.",
-    },
-    de: {
-        title: "Administratorfreigabe",
-        intro: "Dieses Paket kann den festen Vorgang „{op}“ als root ausführen. Ein DSM-Administrator genehmigt ihn einmal mit seinem Passwort. DSM behält ihn dann als deaktivierte Aufgabe im Aufgabenplaner, die nur ausgeführt wird, wenn ein Administrator hier auf „Ausführen“ klickt.",
-        status: "Status",
-        last_run: "Letzte Ausführungszeit",
-        never: "Noch nicht ausgeführt",
-        output: "Ergebnis",
-        "state.checking": "Wird geladen...",
-        "state.missing": "Nicht freigegeben",
-        "state.ready": "Freigegeben",
-        "state.outdated": "Das Paket wurde aktualisiert und muss erneut freigegeben werden",
-        "state.conflict": "Eine andere Aufgabe im Aufgabenplaner verwendet bereits den Namen „{name}“",
-        authorize: "Freigeben",
-        run: "Ausführen",
-        remove: "Entfernen",
-        retry: "Neuer Versuch",
-        completed: "Abgeschlossen",
-        cancelled: "Die Freigabe wurde abgebrochen. Es wurde nichts erstellt.",
-        admin_only: "Nur Administratorkonten können diesen Vorgang ausführen.",
-        uninstall_hint: "Klicken Sie vor der Deinstallation dieses Pakets auf „Entfernen“, um seine Aufgabe aus dem Aufgabenplaner zu löschen.",
-        "error.root_conflict": "Benennen Sie die Aufgabe „{name}“ im Aufgabenplaner um oder löschen Sie sie, und klicken Sie dann auf „Neuer Versuch“.",
-        "error.root_cancelled": "Die Passwortbestätigung wurde abgebrochen. Es wurde keine Aktion ausgeführt.",
-        "error.root_not_ready": "Geben Sie diesen Vorgang zuerst frei.",
-        "error.root_task_failed": "Die Aufgabe wurde mit einem Fehler beendet. Prüfen Sie ihren Verlauf im Aufgabenplaner, und klicken Sie dann auf „Neuer Versuch“.",
-        "error.root_timeout": "Die Aufgabe wurde nicht rechtzeitig beendet. Prüfen Sie sie im Aufgabenplaner, und klicken Sie dann auf „Neuer Versuch“.",
-        "error.root_verify_failed": "Der Aufgabenplaner zeigt die erwartete Aufgabe nicht. Klicken Sie auf „Neuer Versuch“.",
-        "error.default": "Der Vorgang ist fehlgeschlagen ({code}). Klicken Sie auf „Neuer Versuch“.",
-    },
-    fr: {
-        title: "Autorisation de l'administrateur",
-        intro: "Ce paquet peut exécuter l'opération fixe « {op} » en tant que root. Un administrateur DSM l'approuve une fois avec son mot de passe. DSM la conserve ensuite comme tâche désactivée dans le Planificateur de tâches, qui ne s'exécute que lorsqu'un administrateur clique ici sur « Exécuter ».",
-        status: "Statut",
-        last_run: "Dernière heure d'exécution",
-        never: "Pas encore exécutée",
-        output: "Résultat",
-        "state.checking": "Chargement...",
-        "state.missing": "Non autorisée",
-        "state.ready": "Autorisée",
-        "state.outdated": "Le paquet a été mis à jour et doit être autorisé de nouveau",
-        "state.conflict": "Une autre tâche du Planificateur de tâches utilise déjà le nom « {name} »",
-        authorize: "Autoriser",
-        run: "Exécuter",
-        remove: "Supprimer",
-        retry: "Réessayer",
-        completed: "Terminé",
-        cancelled: "L'autorisation a été annulée. Rien n'a été créé.",
-        admin_only: "Seuls les comptes administrateur peuvent effectuer cette opération.",
-        uninstall_hint: "Avant de désinstaller ce paquet, cliquez sur « Supprimer » pour retirer sa tâche du Planificateur de tâches.",
-        "error.root_conflict": "Renommez ou supprimez la tâche « {name} » dans le Planificateur de tâches, puis cliquez sur « Réessayer ».",
-        "error.root_cancelled": "La confirmation du mot de passe a été annulée. Aucune opération n’a été exécutée.",
-        "error.root_not_ready": "Autorisez d'abord cette opération.",
-        "error.root_task_failed": "La tâche s'est terminée avec une erreur. Consultez son historique dans le Planificateur de tâches, puis cliquez sur « Réessayer ».",
-        "error.root_timeout": "La tâche ne s'est pas terminée à temps. Vérifiez-la dans le Planificateur de tâches, puis cliquez sur « Réessayer ».",
-        "error.root_verify_failed": "Le Planificateur de tâches n'affiche pas la tâche attendue. Cliquez sur « Réessayer ».",
-        "error.default": "L'opération a échoué ({code}). Cliquez sur « Réessayer ».",
-    },
-    es: {
-        title: "Autorización del administrador",
-        intro: "Este paquete puede ejecutar la operación fija «{op}» como root. Un administrador de DSM la aprueba una vez con su contraseña. Después, DSM la conserva como una tarea desactivada en el Programador de tareas que solo se ejecuta cuando un administrador hace clic aquí en «Ejecutar».",
-        status: "Estado",
-        last_run: "Hora de la última ejecución",
-        never: "Aún no se ha ejecutado",
-        output: "Resultado",
-        "state.checking": "Cargando...",
-        "state.missing": "No autorizada",
-        "state.ready": "Autorizada",
-        "state.outdated": "El paquete se actualizó y debe autorizarse de nuevo",
-        "state.conflict": "Otra tarea del Programador de tareas ya usa el nombre «{name}»",
-        authorize: "Autorizar",
-        run: "Ejecutar",
-        remove: "Quitar",
-        retry: "Volver a intentar",
-        completed: "Finalizado",
-        cancelled: "Se canceló la autorización. No se creó nada.",
-        admin_only: "Solo las cuentas de administrador pueden realizar esta operación.",
-        uninstall_hint: "Antes de desinstalar este paquete, haga clic en «Quitar» para eliminar su tarea del Programador de tareas.",
-        "error.root_conflict": "Cambie el nombre de la tarea «{name}» o elimínela en el Programador de tareas y, a continuación, haga clic en «Volver a intentar».",
-        "error.root_cancelled": "Se canceló la confirmación de la contraseña. No se ejecutó ninguna operación.",
-        "error.root_not_ready": "Primero autorice esta operación.",
-        "error.root_task_failed": "La tarea terminó con un error. Consulte su historial en el Programador de tareas y, a continuación, haga clic en «Volver a intentar».",
-        "error.root_timeout": "La tarea no terminó a tiempo. Revísela en el Programador de tareas y, a continuación, haga clic en «Volver a intentar».",
-        "error.root_verify_failed": "El Programador de tareas no muestra la tarea esperada. Haga clic en «Volver a intentar».",
-        "error.default": "Error en la operación ({code}). Haga clic en «Volver a intentar».",
-    },
-    it: {
-        title: "Autorizzazione dell'amministratore",
-        intro: "Questo pacchetto può eseguire l'operazione fissa \"{op}\" come root. Un amministratore DSM la approva una volta con la propria password. DSM la conserva quindi come attività disattivata in Utilità di pianificazione, che viene eseguita solo quando un amministratore fa clic qui su \"Esegui\".",
-        status: "Stato",
-        last_run: "Ora ultima esecuzione",
-        never: "Non ancora eseguita",
-        output: "Risultato",
-        "state.checking": "Caricamento...",
-        "state.missing": "Non autorizzata",
-        "state.ready": "Autorizzata",
-        "state.outdated": "Il pacchetto è stato aggiornato e deve essere autorizzato di nuovo",
-        "state.conflict": "Un'altra attività in Utilità di pianificazione usa già il nome \"{name}\"",
-        authorize: "Autorizza",
-        run: "Esegui",
-        remove: "Rimuovi",
-        retry: "Riprova",
-        completed: "Completato",
-        cancelled: "Autorizzazione annullata. Non è stato creato nulla.",
-        admin_only: "Solo gli account administrator possono eseguire questa operazione.",
-        uninstall_hint: "Prima di disinstallare questo pacchetto, fare clic su \"Rimuovi\" per eliminare la sua attività da Utilità di pianificazione.",
-        "error.root_conflict": "Rinominare o eliminare l'attività \"{name}\" in Utilità di pianificazione, quindi fare clic su \"Riprova\".",
-        "error.root_cancelled": "La conferma della password è stata annullata. Nessuna operazione è stata eseguita.",
-        "error.root_not_ready": "Autorizzare prima questa operazione.",
-        "error.root_task_failed": "L'attività è terminata con un errore. Controllarne la cronologia in Utilità di pianificazione, quindi fare clic su \"Riprova\".",
-        "error.root_timeout": "L'attività non è terminata in tempo. Controllarla in Utilità di pianificazione, quindi fare clic su \"Riprova\".",
-        "error.root_verify_failed": "Utilità di pianificazione non mostra l'attività prevista. Fare clic su \"Riprova\".",
-        "error.default": "Operazione non riuscita ({code}). Fare clic su \"Riprova\".",
-    },
-};

package/dist/standalone/worker-contract-json.d.ts

@@ -1,8 +0,0 @@
-import type { WorkerSafeReason } from "./worker-contract.js";
-export declare class WorkerContractError extends Error {
-    readonly code: WorkerSafeReason;
-    constructor(code: WorkerSafeReason);
-}
-export declare function fail(code?: WorkerSafeReason): never;
-export declare function validUnicode(s: string): boolean;
-export declare function strictJSON(raw: string | Uint8Array, cap: number): unknown;

package/dist/standalone/worker-contract-json.js

@@ -1,141 +0,0 @@
-export class WorkerContractError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = "WorkerContractError";
-    }
-}
-export function fail(code = "invalid-request") { throw new WorkerContractError(code); }
-export function validUnicode(s) {
-    for (let i = 0; i < s.length; i++) {
-        const c = s.charCodeAt(i);
-        if (c >= 0xdc00 && c <= 0xdfff)
-            return false;
-        if (c >= 0xd800 && c <= 0xdbff) {
-            const low = s.charCodeAt(++i);
-            if (!(low >= 0xdc00 && low <= 0xdfff))
-                return false;
-        }
-    }
-    return true;
-}
-// JSON.parse alone loses duplicate keys and silently accepts unpaired Unicode.
-// This bounded parser keeps keys until checked; numbers are exact unsigned
-// decimal integers (the Go uint JSON contract rejects fractions/exponents).
-export function strictJSON(raw, cap) {
-    let text;
-    if (typeof raw === "string") {
-        if (!validUnicode(raw))
-            fail();
-        text = raw;
-    }
-    else {
-        if (raw.byteLength > cap)
-            fail("limit-exceeded");
-        try {
-            text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(raw);
-        }
-        catch {
-            return fail();
-        }
-    }
-    if (Buffer.byteLength(text) > cap)
-        fail("limit-exceeded");
-    let i = 0;
-    const space = () => { while (/[ \r\n\t]/.test(text[i] ?? "x"))
-        i++; };
-    const string = () => {
-        const start = i++;
-        while (i < text.length) {
-            const c = text[i++];
-            if (c === "\\") {
-                i++;
-                continue;
-            }
-            if (c === '"') {
-                let value;
-                try {
-                    value = JSON.parse(text.slice(start, i));
-                }
-                catch {
-                    return fail();
-                }
-                if (typeof value !== "string" || !validUnicode(value))
-                    fail();
-                return value;
-            }
-        }
-        return fail();
-    };
-    const value = (depth) => {
-        if (depth > 64)
-            fail();
-        space();
-        const c = text[i];
-        if (c === '"')
-            return string();
-        if (c === "{") {
-            i++;
-            space();
-            const object = Object.create(null);
-            const seen = new Set();
-            if (text[i] !== "}")
-                for (;;) {
-                    if (text[i] !== '"')
-                        fail();
-                    const key = string();
-                    if (seen.has(key))
-                        fail();
-                    seen.add(key);
-                    space();
-                    if (text[i++] !== ":")
-                        fail();
-                    object[key] = value(depth + 1);
-                    space();
-                    if (text[i] === "}")
-                        break;
-                    if (text[i++] !== ",")
-                        fail();
-                    space();
-                }
-            i++;
-            return object;
-        }
-        if (c === "[") {
-            i++;
-            space();
-            const array = [];
-            if (text[i] !== "]")
-                for (;;) {
-                    array.push(value(depth + 1));
-                    space();
-                    if (text[i] === "]")
-                        break;
-                    if (text[i++] !== ",")
-                        fail();
-                }
-            i++;
-            return array;
-        }
-        for (const [word, result] of [["true", true], ["false", false]]) {
-            if (text.startsWith(word, i)) {
-                i += word.length;
-                return result;
-            }
-        }
-        const token = /^(0|[1-9][0-9]*)/.exec(text.slice(i));
-        if (!token)
-            return fail(); // null, negative and invalid primitives
-        i += token[0].length;
-        const n = Number(token[0]);
-        if (!Number.isSafeInteger(n))
-            fail();
-        return n;
-    };
-    const result = value(0);
-    space();
-    if (i !== text.length)
-        fail();
-    return result;
-}