@memorax/memorax-code 0.1.2 → 0.1.4

package/lib/memorax-code-backend/dist/clients/codex/lifecycle.js

@@ -0,0 +1,131 @@
+import { createInterface } from "node:readline/promises";
+import { installCodexPlugin, isCodexPluginActive, isCodexPluginStaged, removeCodexPlugin, } from "./plugin-install.js";
+const BACKEND_PREFIX = "[MemoraX Code Backend]:";
+const GREEN = "\x1b[32m";
+const RESET = "\x1b[0m";
+export async function enableCodexAdapterForStart(argv, serviceOptions, backendUrl) {
+    try {
+        let options = codexAdapterOptions(argv, serviceOptions, backendUrl);
+        const codexHome = typeof options.codexHome === "string" ? options.codexHome : undefined;
+        if (!isCodexPluginActive({ codexHome }) && !isCodexPluginStaged({ codexHome })) {
+            const installed = await maybeInstallCodexPluginForStart(argv);
+            if (installed) {
+                backendLog(green("Codex plugin source registered. Activate the MemoraX Code Codex Adapter plugin, then restart or refresh Codex."));
+            }
+            else if (installed === false) {
+                return codexPluginNotInstalled();
+            }
+        }
+        options = codexAdapterOptions(argv, serviceOptions, backendUrl);
+        if (!isCodexPluginActive({ codexHome })) {
+            return isCodexPluginStaged({ codexHome })
+                ? codexPluginActivationRequired()
+                : codexPluginNotInstalled();
+        }
+        return (await loadCodexAdapterConfig()).enableCodexAdapter(options);
+    }
+    catch (error) {
+        return { ok: false, action: "enable", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function readCodexAdapterStatusForLifecycle(argv, serviceOptions, backendUrl) {
+    try {
+        return (await loadCodexAdapterConfig()).readCodexAdapterStatus(codexAdapterOptions(argv, serviceOptions, backendUrl));
+    }
+    catch (error) {
+        return { ok: false, action: "status", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function disableCodexAdapterForLifecycle(argv, serviceOptions) {
+    try {
+        return (await loadCodexAdapterConfig()).disableCodexAdapter(codexAdapterOptions(argv, serviceOptions));
+    }
+    catch (error) {
+        return { ok: false, action: "disable", error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export const codexAdapterLifecycle = {
+    status: ({ argv, serviceOptions, backendUrl }) => (readCodexAdapterStatusForLifecycle(argv, serviceOptions, backendUrl)),
+    prepareEnable: ({ argv, serviceOptions, backendUrl }) => (enableCodexAdapterForStart(argv, serviceOptions, backendUrl)),
+    disable: ({ argv, serviceOptions }) => (disableCodexAdapterForLifecycle(argv, serviceOptions)),
+    remove: ({ argv }) => removeCodexPlugin(codexPluginRemoveOptions(argv)),
+};
+function codexAdapterOptions(argv, serviceOptions, backendUrl) {
+    const codexHome = argValue(argv, "--codex-home");
+    return {
+        ...(codexHome ? { codexHome } : {}),
+        memoraxCodeHome: serviceOptions.home,
+        ...(backendUrl ? { backendUrl } : {}),
+    };
+}
+function codexPluginNotInstalled() {
+    return {
+        ok: true,
+        action: "enable",
+        skipped: true,
+        reason: "codex_plugin_not_installed",
+        message: "Codex plugin is not installed; run `memorax-code codex-plugin install`, then activate it and rerun `memorax-code start`.",
+    };
+}
+function codexPluginActivationRequired() {
+    return {
+        ok: true,
+        action: "enable",
+        skipped: true,
+        reason: "codex_plugin_activation_required",
+        message: "Codex plugin source is registered but not active; run `memorax-code codex-plugin activate --yes`, then rerun `memorax-code start`.",
+    };
+}
+async function maybeInstallCodexPluginForStart(argv) {
+    if (argv.includes("--json"))
+        return undefined;
+    if (argv.includes("--yes")) {
+        await installCodexPlugin(codexPluginInstallOptions(argv));
+        return true;
+    }
+    if (!canPromptOnStdin())
+        return undefined;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${BACKEND_PREFIX} Install MemoraX Code Codex Adapter plugin now? [y/N] `);
+        if (!process.stdout.isTTY)
+            process.stdout.write("\n");
+        if (!/^y(?:es)?$/i.test(answer.trim()))
+            return false;
+        await installCodexPlugin(codexPluginInstallOptions(argv));
+        return true;
+    }
+    finally {
+        rl.close();
+    }
+}
+function codexPluginInstallOptions(argv) {
+    return {
+        codexHome: argValue(argv, "--codex-home"),
+        marketplacePath: argValue(argv, "--marketplace-path"),
+        pluginSourcePath: argValue(argv, "--plugin-source-path"),
+        codexCommand: argValue(argv, "--codex-command"),
+    };
+}
+function codexPluginRemoveOptions(argv) {
+    return {
+        ...codexPluginInstallOptions(argv),
+        workspace: argValue(argv, "--workspace"),
+    };
+}
+function canPromptOnStdin() {
+    return process.stdin.isTTY === true;
+}
+function backendLog(message) {
+    console.log(`${BACKEND_PREFIX} ${message}`);
+}
+function green(value) {
+    return `${GREEN}${value}${RESET}`;
+}
+function argValue(argv, name) {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : undefined;
+}
+async function loadCodexAdapterConfig() {
+    return await import(new URL("../../../../memorax-code-codex-adapter/src/config.mjs", import.meta.url).href);
+}

package/lib/memorax-code-backend/dist/{codex-memory-hook-runtime.js → clients/codex/memory-hook-runtime.js}

@@ -1,12 +1,12 @@
-import { readCodexInterruptedRolloutTurn, readCodexRolloutTurn, } from "./codex-rollout-turn.js";
-import { createAutomaticMemoryWritebackRuntime, } from "./automatic-memory-writeback.js";
-import { retrieveAutomaticMemoryContext } from "./automatic-memory-retrieval.js";
-import { readCodexSessionTurnIndex } from "./codex-session-turn-index.js";
-import { resolveCodexWorkspaceRoot } from "./codex-workspace-links.js";
-import { createMemoryTurnCoordinator, } from "./memory-turn-coordinator.js";
-import { createRepositoryMemorySessionRuntime, resolvedRepoMemoryWorktree, } from "./repository-memory-context.js";
-import { traceContextFromHookBody } from "./trace-context.js";
-import { markCurrentCodexTurnOutcome, readCurrentCodexTurn, readOpenCodexTurn, recordCodexTraceEvent, traceTurnEventId, writeCurrentCodexTurn, } from "./trace-store.js";
+import { readCodexInterruptedRolloutTurn, readCodexRolloutTurn, } from "./rollout-turn.js";
+import { createAutomaticMemoryWritebackRuntime, } from "../../memory/automatic-writeback.js";
+import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { readCodexSessionTurnIndex } from "./session-turn-index.js";
+import { resolveCodexWorkspaceRoot } from "./workspace-links.js";
+import { createMemoryTurnCoordinator, } from "../../memory/turn-coordinator.js";
+import { createRepositoryMemorySessionRuntime, resolvedRepoMemoryWorktree, } from "../../memory/repository-session.js";
+import { traceContextFromHookBody } from "../../trace/context.js";
+import { markCurrentCodexTurnOutcome, readCurrentCodexTurn, readOpenCodexTurn, recordCodexTraceEvent, traceTurnEventId, writeCurrentCodexTurn, } from "../../trace/store.js";
 const CODEX_MEMORY_TURN_CLIENT = "codex";
 export function createCodexMemoryHookRuntime(options = {}) {
     const now = options.now ?? (() => Date.now());

package/lib/memorax-code-backend/dist/{codex-plugin-hooks.js → clients/codex/plugin-hooks.js}

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { homedir } from "node:os";
 import { join, resolve, sep } from "node:path";
-import { resolveWindowsCliInvocation } from "./windows-cli-invocation.js";
+import { resolveWindowsCliInvocation } from "../../shared/windows-cli-invocation.js";
 const PLUGIN_NAME = "memorax-code-codex-adapter";
 const CLI_MARKETPLACE_NAME = "memorax-code";
 const APP_SERVER_OPERATION_TIMEOUT_MS = 10_000;

package/lib/memorax-code-backend/dist/{codex-plugin-install.js → clients/codex/plugin-install.js}

@@ -5,10 +5,10 @@ import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { activeCodexPluginRoot, isCompleteCodexPluginArtifact, } from "../../memorax-code-adapter-common/src/clients/codex-plugin-artifact.mjs";
-import { atomicWriteJson } from "../../memorax-code-adapter-common/src/config-utils.mjs";
-import { confirmHookTrust, listMemoraxCodeHooks, trustCodexPluginHookSelection, } from "./codex-plugin-hooks.js";
-import { resolveWindowsCliInvocation } from "./windows-cli-invocation.js";
+import { activeCodexPluginRoot, isCompleteCodexPluginArtifact, } from "../../../../memorax-code-adapter-common/src/clients/codex-plugin-artifact.mjs";
+import { atomicWriteJson } from "../../../../memorax-code-adapter-common/src/config-utils.mjs";
+import { confirmHookTrust, listMemoraxCodeHooks, trustCodexPluginHookSelection, } from "./plugin-hooks.js";
+import { resolveWindowsCliInvocation } from "../../shared/windows-cli-invocation.js";
 const PLUGIN_NAME = "memorax-code-codex-adapter";
 const CLI_MARKETPLACE_NAME = "memorax-code";
 const ADAPTER_COMMON_NAME = "memorax-code-adapter-common";
@@ -263,8 +263,8 @@ function stringField(record, key) {
 function adapterSourceRoot() {
     const current = dirname(fileURLToPath(import.meta.url));
     const candidates = [
-        resolve(current, "..", "..", "memorax-code-codex-adapter"),
-        resolve(current, "..", "memorax-code-codex-adapter"),
+        resolve(current, "..", "..", "..", "..", "memorax-code-codex-adapter"),
+        resolve(current, "..", "..", "..", "memorax-code-codex-adapter"),
     ];
     const found = candidates.find((candidate) => existsSync(join(candidate, ".codex-plugin", "plugin.json")));
     if (!found)

package/lib/memorax-code-backend/dist/clients/dsh/lifecycle.js

@@ -0,0 +1,75 @@
+export async function collectDshAdapterLifecycleStatus(context) {
+    try {
+        return normalizeDshReport((await loadDshProfileLifecycle()).collectDshAdapterStatus(dshAdapterOptions(context)));
+    }
+    catch (error) {
+        return dshFailure("status", error);
+    }
+}
+/**
+ * Keep the DSH state lock for a complete Backend lifecycle command. The caller
+ * already owns the Backend lifecycle lock, establishing one lock order for
+ * both user commands and native DSH recovery.
+ */
+export async function withDshAdapterLifecycleLock(context, operation) {
+    const module = await loadDshProfileLifecycle();
+    return module.withDshPluginLifecycleLock(dshAdapterOptions(context), (lifecycle) => (operation(lockedDshAdapterLifecycle(lifecycle))));
+}
+function lockedDshAdapterLifecycle(lifecycle) {
+    return {
+        status: () => runLockedDshPhase("status", () => lifecycle.status()),
+        prepareEnable: () => runLockedDshPhase("prepareEnable", () => lifecycle.ensureInstalled({ enabled: false })),
+        activate: () => runLockedDshPhase("activate", () => lifecycle.activate()),
+        quiesce: () => runLockedDshPhase("quiesce", () => lifecycle.quiesce()),
+        disable: () => runLockedDshPhase("disable", () => lifecycle.disable()),
+        remove: () => runLockedDshPhase("remove", () => lifecycle.remove()),
+    };
+}
+async function runLockedDshPhase(action, operation) {
+    try {
+        return normalizeDshReport(operation());
+    }
+    catch (error) {
+        return dshFailure(action, error);
+    }
+}
+function normalizeDshReport(report) {
+    return {
+        integration: "plugin",
+        runtime: "dsh",
+        ...report,
+    };
+}
+function dshAdapterOptions(context) {
+    const { argv, serviceOptions } = context;
+    return {
+        memoraxCodeHome: serviceOptions.home,
+        ...(argValue(argv, "--dsh-home") ? { dshHome: argValue(argv, "--dsh-home") } : {}),
+        ...(argValue(argv, "--dsh-command") ? { dshCommand: argValue(argv, "--dsh-command") } : {}),
+        ...(argValue(argv, "--dsh-adapter-root")
+            ? { adapterRoot: argValue(argv, "--dsh-adapter-root") }
+            : {}),
+        ...(argValue(argv, "--memorax-code-command")
+            ? { memoraxCodeCommand: argValue(argv, "--memorax-code-command") }
+            : {}),
+    };
+}
+function dshFailure(action, error) {
+    return {
+        ok: false,
+        action,
+        integration: "plugin",
+        runtime: "dsh",
+        error: error instanceof Error ? error.message : String(error),
+    };
+}
+async function loadDshProfileLifecycle() {
+    return await import(new URL("../../../../memorax-code-dsh-adapter/src/profile-lifecycle.mjs", import.meta.url).href);
+}
+function argValue(argv, name) {
+    const index = argv.indexOf(name);
+    if (index >= 0)
+        return argv[index + 1];
+    const inline = argv.find((arg) => arg.startsWith(`${name}=`));
+    return inline?.slice(name.length + 1);
+}

package/lib/memorax-code-backend/dist/clients/dsh/memory-hook-runtime.js

@@ -0,0 +1,258 @@
+import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { resolvedRepoMemoryWorktree, } from "../../memory/repository-session.js";
+import { dshSessionEventTurn, } from "./session-turn.js";
+import { traceContextFromDshSessionEventLog, traceContextFromDshTurnStart, } from "../../trace/context.js";
+import { markCurrentTraceTurnOutcome, recordTraceEvent, traceTurnEventId, writeCurrentTraceTurn, } from "../../trace/store.js";
+const DSH_MEMORY_TURN_CLIENT = "dsh";
+export function createDshMemoryHookRuntime(options) {
+    const now = options.now ?? (() => Date.now());
+    const { repositoryMemorySession, turnCoordinator } = options;
+    const retrievalTurns = new Set();
+    const retrievalTurnLimit = positiveInteger(options.maxEntries, 256);
+    return {
+        async recordTurnStart(command) {
+            turnCoordinator.pruneExpired();
+            const createdAt = now();
+            const traceContext = traceContextFromDshTurnStart(command, new Date(createdAt).toISOString());
+            const repositoryMemory = await resolveHookRepositoryMemory(command, options, repositoryMemorySession);
+            turnCoordinator.recordTurnStart({
+                client: DSH_MEMORY_TURN_CLIENT,
+                sessionId: command.sessionId,
+                clientTurnId: String(command.turn),
+                cwd: command.cwd,
+                eventStartSeq: command.startSeq,
+                createdAt,
+                traceContext,
+                repositoryMemory,
+            });
+            options.diagnosticLogger?.("dsh_memory.turn_start", {
+                sessionId: command.sessionId,
+                turn: command.turn,
+                startSeq: command.startSeq,
+                cacheSize: turnCoordinator.size(DSH_MEMORY_TURN_CLIENT),
+                workspace: repositoryMemory.ok ? repositoryMemory.memory.scope?.repositorySlug : undefined,
+                workspaceScopeReason: repositoryMemory.ok ? undefined : repositoryMemory.reason,
+            });
+            await recordDshTraceBestEffort("dsh_memory.turn_start_event", recordTraceEvent({
+                eventId: traceTurnEventId(traceContext, "turn_start"),
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                traceContext,
+                type: "turn_start",
+                source: "dsh-cordis",
+                operation: "query",
+                ok: true,
+                request: {
+                    start_seq: command.startSeq,
+                },
+            }), options.diagnosticLogger);
+            await recordDshTraceBestEffort("dsh_memory.current_turn_write", writeCurrentTraceTurn(traceContext, {
+                client: "dsh",
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                now: () => new Date(now()),
+            }), options.diagnosticLogger);
+            const repoMemoryWorktree = resolvedRepoMemoryWorktree(repositoryMemory);
+            const retrievalKey = JSON.stringify([command.sessionId, command.turn, command.startSeq]);
+            if (retrievalTurns.has(retrievalKey)) {
+                return {
+                    ok: true,
+                    ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
+                };
+            }
+            retrievalTurns.add(retrievalKey);
+            while (retrievalTurns.size > retrievalTurnLimit) {
+                const oldest = retrievalTurns.values().next().value;
+                if (typeof oldest !== "string")
+                    break;
+                retrievalTurns.delete(oldest);
+            }
+            const retrieval = await retrieveAutomaticMemoryContext({
+                diagnosticLogger: options.diagnosticLogger,
+                env: options.env ?? process.env,
+                fetchImpl: options.fetchImpl,
+                memoryObservability: options.memoryObservability,
+                memoryObservabilitySource: "dsh_native_retrieval",
+                query: command.prompt,
+                repositoryMemory,
+                sessionKey: command.sessionId,
+                traceContext,
+            });
+            return {
+                ok: true,
+                ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
+                ...(retrieval.context ? { additionalContext: retrieval.context } : {}),
+            };
+        },
+        async writeback(command) {
+            turnCoordinator.pruneExpired();
+            const key = dshTurnKey(command.sessionId, command.turn);
+            const entry = turnCoordinator.getTurn(key);
+            if (entry
+                && (entry.eventStartSeq !== command.startSeq || entry.cwd !== command.cwd))
+                return skippedWriteback(command, "turn_metadata_mismatch", options);
+            const materialized = dshSessionEventTurn(command);
+            if (!materialized.ok) {
+                if (materialized.reason === "turn_not_completed") {
+                    const traceContext = traceContextFromDshSessionEventLog(command);
+                    await recordDshTurnEnd(options, traceContext, {
+                        outcome: "interrupted",
+                        nativeOutcome: materialized.outcome,
+                        startSeq: command.startSeq,
+                        endSeq: command.endSeq,
+                    });
+                    const discarded = turnCoordinator.discardTurn(key, "interrupted");
+                    return skippedWriteback(command, materialized.reason, options, discarded ? "consumed" : "absent");
+                }
+                return skippedWriteback(command, materialized.reason, options);
+            }
+            const traceContext = traceContextFromDshSessionEventLog(command);
+            await recordDshTurnEnd(options, traceContext, {
+                outcome: "completed",
+                nativeOutcome: materialized.turn.outcome,
+                startSeq: materialized.turn.startSeq,
+                endSeq: materialized.turn.endSeq,
+                turn: materialized.turn,
+            });
+            const writeback = await turnCoordinator.completeMaterializedTurn({
+                key,
+                metadata: entry,
+                resolveRepositoryMemory: () => resolveCurrentHookRepositoryMemory(entry, command, options, repositoryMemorySession),
+                userText: materialized.turn.userPrompt,
+                assistantText: materialized.turn.assistantReply,
+                writeback: {
+                    client: DSH_MEMORY_TURN_CLIENT,
+                    sessionKey: command.sessionId,
+                    env: options.env ?? process.env,
+                    fetchImpl: options.fetchImpl,
+                    memoryObservability: options.memoryObservability,
+                    memoryObservabilitySource: "dsh_native_writeback",
+                    traceContext,
+                },
+            });
+            if (!writeback.scheduled) {
+                return skippedWriteback(command, writeback.reason, options, writeback.metadataDisposition);
+            }
+            options.diagnosticLogger?.("dsh_memory.writeback", {
+                scheduled: true,
+                metadataDisposition: writeback.metadataDisposition,
+                sessionId: command.sessionId,
+                turn: command.turn,
+                startSeq: command.startSeq,
+                endSeq: command.endSeq,
+                outcome: materialized.turn.outcome,
+                promptChars: materialized.turn.userPrompt.length,
+                assistantChars: materialized.turn.assistantReply.length,
+                contentSource: "dsh_session_event_interval",
+            });
+            return { ok: true, scheduled: true };
+        },
+        close() {
+            retrievalTurns.clear();
+        },
+    };
+}
+async function recordDshTurnEnd(options, traceContext, details) {
+    const eventId = traceTurnEventId(traceContext, "turn_end");
+    const recorded = await recordDshTraceBestEffort("dsh_memory.turn_end_event", recordTraceEvent({
+        eventId,
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+        traceContext,
+        type: "turn_end",
+        source: "dsh-session-event-log",
+        operation: "reply",
+        ok: true,
+        outcome: details.outcome,
+        request: {
+            start_seq: details.startSeq,
+            end_seq: details.endSeq,
+            native_outcome: details.nativeOutcome,
+        },
+    }), options.diagnosticLogger);
+    if (!recorded || (!recorded.written && recorded.reason !== "duplicate_event"))
+        return;
+    if (details.turn && eventId) {
+        await recordDshTraceBestEffort("dsh_memory.turn_materialized_event", recordTraceEvent({
+            eventId: traceTurnEventId(traceContext, "turn_materialized"),
+            memoraxCodeHome: options.memoraxCodeHome,
+            env: options.env,
+            traceContext,
+            type: "turn_materialized",
+            source: "dsh-session-event-log",
+            operation: "reply",
+            ok: true,
+            outcome: details.outcome,
+            request: {
+                original_event_id: eventId,
+                start_seq: details.startSeq,
+                end_seq: details.endSeq,
+                prompt: details.turn.userPrompt,
+            },
+            response: {
+                assistantMessage: details.turn.assistantReply,
+            },
+        }), options.diagnosticLogger);
+    }
+    await recordDshTraceBestEffort("dsh_memory.current_turn_close", markCurrentTraceTurnOutcome(traceContext, details.outcome, {
+        client: "dsh",
+        memoraxCodeHome: options.memoraxCodeHome,
+        env: options.env,
+    }), options.diagnosticLogger);
+}
+async function recordDshTraceBestEffort(label, promise, diagnosticLogger) {
+    try {
+        return await promise;
+    }
+    catch (error) {
+        diagnosticLogger?.("dsh_trace.write_failed", {
+            label,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return undefined;
+    }
+}
+function dshTurnKey(sessionId, turn) {
+    return {
+        client: DSH_MEMORY_TURN_CLIENT,
+        sessionId,
+        clientTurnId: String(turn),
+    };
+}
+async function resolveHookRepositoryMemory(command, options, repositoryMemorySession) {
+    return await repositoryMemorySession.resolve({
+        client: DSH_MEMORY_TURN_CLIENT,
+        sessionId: command.sessionId,
+        workspaceRoot: command.cwd,
+        memoraxCodeHome: options.memoraxCodeHome ?? options.env?.MEMORAX_CODE_HOME,
+        env: options.env,
+    });
+}
+async function resolveCurrentHookRepositoryMemory(entry, command, options, repositoryMemorySession) {
+    return await repositoryMemorySession.resolve({
+        client: DSH_MEMORY_TURN_CLIENT,
+        sessionId: command.sessionId,
+        workspaceRoot: command.cwd,
+        // DSH's persisted session header and exact event interval remain native
+        // authority after a Backend restart, when the in-memory binding is gone.
+        requireBoundScope: entry !== undefined,
+        memoraxCodeHome: options.memoraxCodeHome ?? options.env?.MEMORAX_CODE_HOME,
+        env: options.env,
+    });
+}
+function skippedWriteback(command, reason, options, metadataDisposition = "retained") {
+    options.diagnosticLogger?.("dsh_memory.writeback", {
+        scheduled: false,
+        reason,
+        metadataDisposition,
+        sessionId: command.sessionId,
+        turn: command.turn,
+        startSeq: command.startSeq,
+        endSeq: command.endSeq,
+    });
+    return { ok: true, scheduled: false, reason };
+}
+function positiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}