@minionry/minion 0.7.36

package/dist/server/services/plan/parser.js

@@ -0,0 +1,258 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { resolveSpecsDir, specsDirOrDefault } from '../space-layout.js';
+import { deriveIssueEffortsFromFacts, sessionFactsReaderFor } from './issue-effort.js';
+import { parseBoard, parseIssue, parseMilestone, parseProjectConfig, parseProjectState, parseSprint, parseWorkspace } from './parser-core.js';
+import { isLegacyFormat, migrateToBoards } from './parser-migration.js';
+import { readLatestQualityDeltas, summarizeQualityDelta } from './quality-delta.js';
+export const NO_SPECS_DIR_ERROR = 'No Specs directory found';
+export function isBoardCentricFormat(pmDir) {
+    return existsSync(join(pmDir, 'boards'));
+}
+export function resolvePmDir(workingDir) {
+    return resolveSpecsDir(workingDir);
+}
+export function defaultPmDir(workingDir) {
+    return specsDirOrDefault(workingDir);
+}
+export function planDirExists(workingDir) {
+    return resolvePmDir(workingDir) !== null;
+}
+function readFileIfExists(path) {
+    try {
+        if (existsSync(path))
+            return readFileSync(path, 'utf-8');
+    }
+    catch {   }
+    return null;
+}
+function readMdFilesInDir(dirPath) {
+    if (!existsSync(dirPath))
+        return [];
+    try {
+        return readdirSync(dirPath)
+            .filter(f => f.endsWith('.md'))
+            .map(name => ({ name, content: readFileSync(join(dirPath, name), 'utf-8') }));
+    }
+    catch {
+        return [];
+    }
+}
+function listDirFiles(dirPath, ext) {
+    if (!existsSync(dirPath))
+        return [];
+    try {
+        return readdirSync(dirPath).filter(f => f.endsWith(ext));
+    }
+    catch {
+        return [];
+    }
+}
+function readReviewResults(reviewsDir) {
+    const results = [];
+    for (const f of listDirFiles(reviewsDir, '.json')) {
+        const content = readFileIfExists(join(reviewsDir, f));
+        if (content)
+            results.push(JSON.parse(content));
+    }
+    return results;
+}
+function attachQualityDeltas(boardDir, issues) {
+    const latest = readLatestQualityDeltas(boardDir);
+    for (const issue of issues) {
+        const record = latest.get(issue.id);
+        issue.qualityDelta = record ? summarizeQualityDelta(record) : null;
+    }
+    return issues;
+}
+function attachIssueEfforts(pmDir, boardDir, issues) {
+    const workingDir = dirname(dirname(pmDir));
+    const efforts = deriveIssueEffortsFromFacts(boardDir, issues, sessionFactsReaderFor(workingDir));
+    for (const issue of issues)
+        issue.effort = efforts.get(issue.id) ?? null;
+    return issues;
+}
+function attachBoardFacts(pmDir, boardDir, issues) {
+    return attachIssueEfforts(pmDir, boardDir, attachQualityDeltas(boardDir, issues));
+}
+const defaultProject = {
+    name: '', id: '', created: '', status: 'active', estimation: 'none',
+    idPrefixes: {}, workflows: [], labels: [], teams: [],
+};
+const defaultState = {
+    project: '', currentSprint: null, activeMilestone: null, paused: false,
+    lastSession: null, readyToWork: [], inProgress: [], blocked: [],
+    recentlyCompleted: [], warnings: [],
+};
+export function parseBoardDirectory(pmDir, boardId) {
+    const boardDir = join(pmDir, 'boards', boardId);
+    if (!existsSync(boardDir))
+        return null;
+    const boardContent = readFileIfExists(join(boardDir, 'board.md'));
+    if (!boardContent)
+        return null;
+    const board = parseBoard(boardContent, `boards/${boardId}/board.md`);
+    const stateContent = readFileIfExists(join(boardDir, 'STATE.md'));
+    const state = stateContent ? parseProjectState(stateContent) : { ...defaultState };
+    const issueFiles = readMdFilesInDir(join(boardDir, 'backlog'));
+    const boardPrefix = `boards/${boardId}/`;
+    const issues = issueFiles.map(f => {
+        const issue = parseIssue(f.content, `${boardPrefix}backlog/${f.name}`);
+        issue.blockedBy = issue.blockedBy.map(bp => bp.startsWith('boards/') ? bp : `${boardPrefix}${bp}`);
+        issue.blocks = issue.blocks.map(bp => bp.startsWith('boards/') ? bp : `${boardPrefix}${bp}`);
+        if (issue.epic && !issue.epic.startsWith('boards/'))
+            issue.epic = `${boardPrefix}${issue.epic}`;
+        if (issue.children.length > 0) {
+            issue.children = issue.children.map(cp => cp.startsWith('boards/') ? cp : `${boardPrefix}${cp}`);
+        }
+        return issue;
+    });
+    return { board, state, issues: attachBoardFacts(pmDir, boardDir, issues) };
+}
+function parseBoardCentricState(planDir) {
+    const workspaceContent = readFileIfExists(join(planDir, 'workspace.json'));
+    const workspace = workspaceContent ? parseWorkspace(workspaceContent) : { activeBoardId: null, boardOrder: [] };
+    const boards = [];
+    const boardsDir = join(planDir, 'boards');
+    if (existsSync(boardsDir)) {
+        for (const entry of readdirSync(boardsDir)) {
+            const boardMdPath = join(boardsDir, entry, 'board.md');
+            if (!existsSync(boardMdPath))
+                continue;
+            boards.push(parseBoard(readFileSync(boardMdPath, 'utf-8'), `boards/${entry}/board.md`));
+        }
+    }
+    const orderMap = new Map(workspace.boardOrder.map((id, i) => [id, i]));
+    boards.sort((a, b) => (orderMap.get(a.id) ?? 999) - (orderMap.get(b.id) ?? 999));
+    const activeBoard = workspace.activeBoardId ? parseBoardDirectory(planDir, workspace.activeBoardId) : null;
+    return { boards, workspace, activeBoard };
+}
+export function parsePlanDirectory(workingDir) {
+    const planDir = resolvePmDir(workingDir);
+    if (!planDir)
+        return null;
+    if (isLegacyFormat(planDir))
+        migrateToBoards(planDir);
+    const projectContent = readFileIfExists(join(planDir, 'project.md'));
+    const project = projectContent ? parseProjectConfig(projectContent) : { ...defaultProject };
+    const milestoneFiles = readMdFilesInDir(join(planDir, 'milestones'));
+    const milestones = milestoneFiles.map(f => parseMilestone(f.content, `milestones/${f.name}`));
+    if (!isBoardCentricFormat(planDir)) {
+        return {
+            project, state: { ...defaultState }, boards: [], workspace: { activeBoardId: null, boardOrder: [] },
+            activeBoard: null, issues: [], sprints: [], milestones,
+        };
+    }
+    const { boards, workspace, activeBoard } = parseBoardCentricState(planDir);
+    return {
+        project, state: activeBoard?.state ?? { ...defaultState },
+        boards, workspace, activeBoard, issues: activeBoard?.issues ?? [],
+        sprints: [], milestones,
+    };
+}
+export function parseSingleIssue(workingDir, issuePath) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const content = readFileIfExists(join(pmDir, issuePath));
+    if (!content)
+        return null;
+    const issue = parseIssue(content, issuePath);
+    const boardMatch = issuePath.match(/^boards\/([^/]+)\//);
+    return boardMatch ? attachBoardFacts(pmDir, join(pmDir, 'boards', boardMatch[1]), [issue])[0] : issue;
+}
+export function parseSingleSprint(workingDir, sprintPath) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const content = readFileIfExists(join(pmDir, sprintPath));
+    if (!content)
+        return null;
+    return parseSprint(content, sprintPath);
+}
+export function parseSingleMilestone(workingDir, milestonePath) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const content = readFileIfExists(join(pmDir, milestonePath));
+    if (!content)
+        return null;
+    return parseMilestone(content, milestonePath);
+}
+export function getNextId(issues, prefix) {
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`^${escaped}-(\\d+)$`);
+    let max = 0;
+    for (const issue of issues) {
+        const match = issue.id.match(pattern);
+        if (match) {
+            const num = Number.parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return `${prefix}-${String(max + 1).padStart(3, '0')}`;
+}
+export function getNextBoardId(boards) {
+    let max = 0;
+    for (const board of boards) {
+        const match = board.id.match(/^BOARD-(\d+)$/);
+        if (match) {
+            const num = Number.parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return `BOARD-${String(max + 1).padStart(3, '0')}`;
+}
+export function getNextBoardNumber(boards) {
+    let max = 0;
+    for (const board of boards) {
+        const match = board.title.match(/^Board (\d+)$/);
+        if (match) {
+            const num = Number.parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return max + 1;
+}
+export function parseBoardArtifacts(workingDir, boardId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const boardDir = join(pmDir, 'boards', boardId);
+    if (!existsSync(boardDir))
+        return null;
+    const progressLog = readFileIfExists(join(boardDir, 'progress.md')) ?? '';
+    const outputFiles = listDirFiles(join(boardDir, 'out'), '.md');
+    const reviewResults = readReviewResults(join(boardDir, 'reviews'));
+    const executionLogs = listDirFiles(join(boardDir, 'logs'), '.log').sort();
+    return { boardId, progressLog, outputFiles, reviewResults, executionLogs };
+}
+export function getNextSprintId(sprints) {
+    let max = 0;
+    for (const sprint of sprints) {
+        const match = sprint.id.match(/^SPRINT-(\d+)$/);
+        if (match) {
+            const num = Number.parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return `SPRINT-${String(max + 1).padStart(3, '0')}`;
+}
+export function parseSprintArtifacts(workingDir, sprintId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const sandboxDir = join(pmDir, 'sprints', sprintId);
+    if (!existsSync(sandboxDir))
+        return null;
+    const progressLog = readFileIfExists(join(sandboxDir, 'progress.md')) ?? '';
+    const outputFiles = listDirFiles(join(sandboxDir, 'out'), '.md');
+    const reviewResults = readReviewResults(join(sandboxDir, 'reviews'));
+    return { sprintId, progressLog, outputFiles, reviewResults };
+}

package/dist/server/services/plan/plan-runner-factory.js

@@ -0,0 +1,68 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeEffort } from '../../cli/headless/claude-invoker-process.js';
+import { ResilientRunner } from '../../cli/headless/resilient-runner.js';
+import { engineForModel, parseEngineId } from '../../engines/types.js';
+import { getEngine } from '../../services/settings.js';
+export function resolveIssueExecutionTarget(issue, globalEngine = getEngine()) {
+    const explicitEngine = parseEngineId(issue.engine);
+    const model = issue.model || undefined;
+    const engineId = explicitEngine ?? (model ? engineForModel(model) : globalEngine);
+    const source = explicitEngine ? 'issue-engine' : model ? 'issue-model' : 'global';
+    return {
+        engineId,
+        model,
+        effortLevel: issue.effortLevel ?? undefined,
+        fastMode: issue.fastMode ?? undefined,
+        source,
+    };
+}
+export function toExecutionTargetInfo(target) {
+    return {
+        engine: target.engineId,
+        model: target.model,
+        effortLevel: target.engineId === 'claude-code'
+            ? (resolveClaudeEffort(target.model, target.effortLevel ?? 'auto') ?? target.effortLevel)
+            : target.effortLevel,
+        fastMode: target.fastMode,
+    };
+}
+const PHASE_DEFAULTS = {
+    synthesis: {
+        policy: 'NONE',
+        stallWarningMs: 60_000,
+        stallKillMs: 120_000,
+        stallHardCapMs: 180_000,
+    },
+    planning: {
+        policy: 'STANDARD',
+        stallWarningMs: 300_000,
+        stallKillMs: 900_000,
+        stallHardCapMs: 7_200_000,
+    },
+    review: {
+        policy: 'STANDARD',
+        stallWarningMs: 300_000,
+        stallKillMs: 600_000,
+        stallHardCapMs: 2_700_000,
+    },
+    issue: {
+        policy: 'FULL',
+        maxRetries: 3,
+    },
+};
+export function createPlanRunner(kind, config) {
+    const defaults = PHASE_DEFAULTS[kind];
+    const overrides = {};
+    for (const key of Object.keys(config)) {
+        if (config[key] !== undefined) {
+            overrides[key] = config[key];
+        }
+    }
+    return new ResilientRunner({
+        ...defaults,
+        ...overrides,
+        workingDir: config.workingDir,
+        prompt: config.prompt,
+    });
+}

package/dist/server/services/plan/pm-timeline.js

@@ -0,0 +1,320 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { applyTimelineEvent, CHAT_TIMELINE_CONTRACT_VERSION, classifyEngineOutput, DEFAULT_CHAT_TIMELINE_LIMITS, emptyTimelineState, timelineEventEntryId, } from '../timeline/index.js';
+export const PM_COMPOSER_ISSUE_ID = 'composer';
+export const PM_BOARD_ISSUE_ID = 'system';
+export function pmTimelineIssueId(issueId) {
+    if (!issueId)
+        return PM_COMPOSER_ISSUE_ID;
+    if (issueId === 'system' || issueId === 'recovery' || issueId.startsWith('wave['))
+        return PM_BOARD_ISSUE_ID;
+    return issueId;
+}
+const INGESTED_PM_EVENTS = new Set([
+    'planExecutionOutput',
+    'planExecutionToolUse',
+    'planExecutionTokens',
+    'planReviewProgress',
+    'planExecutionPrompt',
+    'planExecutionProgress',
+    'planExecutionError',
+    'planPromptStreaming',
+    'planPromptToolUse',
+    'planPromptTokens',
+]);
+export function isTimelinePmEvent(type) {
+    return INGESTED_PM_EVENTS.has(type);
+}
+export class PmTimeline {
+    limits;
+    state = emptyTimelineState();
+    nextEntryId = 1;
+    approxBytes = 0;
+    entryBytes = new Map();
+    toolEntries = new Map();
+    constructor(limits = DEFAULT_CHAT_TIMELINE_LIMITS) {
+        this.limits = limits;
+    }
+    entryCount() {
+        return this.state.entries.length;
+    }
+    byteSize() {
+        return this.approxBytes;
+    }
+    isEmpty() {
+        return this.state.entries.length === 0 && this.state.tokens === null;
+    }
+    snapshot(seq) {
+        return {
+            seq,
+            entries: JSON.parse(JSON.stringify(this.state.entries)),
+            status: { ...this.state.status },
+            tokens: this.state.tokens ? { ...this.state.tokens } : null,
+            truncated: this.state.truncated,
+            version: CHAT_TIMELINE_CONTRACT_VERSION,
+        };
+    }
+    ingest(type, data, at = Date.now()) {
+        if (!isTimelinePmEvent(type))
+            return [];
+        const raw = asRecord(data);
+        const out = [];
+        switch (type) {
+            case 'planExecutionOutput':
+                this.ingestOutput(out, str(raw.text), at);
+                break;
+            case 'planPromptStreaming':
+                this.ingestOutput(out, str(raw.token), at);
+                break;
+            case 'planExecutionToolUse':
+            case 'planPromptToolUse':
+                this.ingestToolUse(out, asRecord(raw.event), at);
+                break;
+            case 'planExecutionTokens':
+            case 'planPromptTokens':
+                this.record(out, { kind: 'tokens', at, usage: tokenUsage(raw) });
+                break;
+            case 'planReviewProgress':
+                this.ingestNotice(out, 'info', `Review: ${str(raw.status) || 'unknown'}`, 'REVIEW_PROGRESS', at, {
+                    status: str(raw.status),
+                });
+                break;
+            case 'planExecutionPrompt': {
+                const prompt = str(raw.prompt);
+                const last = this.state.entries[this.state.entries.length - 1];
+                if (prompt && !(last?.kind === 'user' && last.text === prompt)) {
+                    this.record(out, { kind: 'user', at, entryId: this.allocEntryId(), text: prompt });
+                }
+                this.record(out, { kind: 'status', at, executing: true });
+                break;
+            }
+            case 'planExecutionProgress':
+                if (str(raw.status) === 'done') {
+                    this.ingestNotice(out, 'info', 'Completed', 'ISSUE_COMPLETE', at);
+                    this.record(out, { kind: 'status', at, executing: false });
+                }
+                break;
+            case 'planExecutionError':
+                this.ingestNotice(out, 'error', `Error: ${str(raw.error) || 'Unknown error'}`, 'ISSUE_ERROR', at);
+                this.record(out, { kind: 'status', at, executing: false });
+                break;
+            default:
+                return out;
+        }
+        this.enforceLimits(out, at);
+        return out;
+    }
+    ingestOutput(out, text, at) {
+        for (const chunk of classifyEngineOutput(text)) {
+            if (chunk.kind === 'notice') {
+                this.ingestNotice(out, chunk.level, chunk.text, chunk.code, at);
+            }
+            else {
+                this.ingestStream(out, chunk.kind === 'thinking' ? 'thinking' : 'text', chunk.text, at);
+            }
+        }
+    }
+    ingestStream(out, kind, delta, at) {
+        if (delta === '')
+            return;
+        const entryId = this.openEntryId(kind) ?? this.allocEntryId();
+        this.record(out, { kind, at, entryId, delta });
+    }
+    ingestToolUse(out, raw, at) {
+        const phase = str(raw.type);
+        if (phase === 'tool_input_delta')
+            return;
+        const toolId = str(raw.toolId);
+        if (phase === 'tool_result') {
+            const entryId = this.resolveToolEntry(out, toolId, str(raw.toolName) || 'Tool', {}, at);
+            this.record(out, {
+                kind: 'tool_result',
+                at,
+                entryId,
+                ok: raw.isError !== true,
+                result: clampText(str(raw.result) || 'No output', this.limits.maxToolResultChars),
+            });
+            if (toolId)
+                this.toolEntries.delete(toolId);
+            return;
+        }
+        const input = clampInput(raw.completeInput, this.limits.maxToolInputChars);
+        const existing = toolId ? this.toolEntries.get(toolId) : undefined;
+        const entryId = existing ?? this.allocEntryId();
+        if (toolId)
+            this.toolEntries.set(toolId, entryId);
+        this.record(out, {
+            kind: 'tool_use',
+            at,
+            entryId,
+            toolName: str(raw.toolName) || 'Unknown Tool',
+            ...(toolId ? { toolUseId: toolId } : {}),
+            input,
+        });
+    }
+    ingestNotice(out, level, text, code, at, data) {
+        this.record(out, {
+            kind: 'notice',
+            at,
+            entryId: this.allocEntryId(),
+            level,
+            text: clampText(text, this.limits.maxToolResultChars),
+            code,
+            ...(data ? { data } : {}),
+        });
+    }
+    resolveToolEntry(out, toolId, toolName, input, at) {
+        const known = toolId ? this.toolEntries.get(toolId) : undefined;
+        if (known)
+            return known;
+        const entryId = this.allocEntryId();
+        if (toolId)
+            this.toolEntries.set(toolId, entryId);
+        this.record(out, {
+            kind: 'tool_use',
+            at,
+            entryId,
+            toolName,
+            ...(toolId ? { toolUseId: toolId } : {}),
+            input,
+        });
+        return entryId;
+    }
+    allocEntryId() {
+        return String(this.nextEntryId++);
+    }
+    openEntryId(kind) {
+        const last = this.state.entries[this.state.entries.length - 1];
+        return last && last.kind === kind && last.open ? last.id : null;
+    }
+    record(out, event) {
+        applyTimelineEvent(this.state, event);
+        this.chargeBytes(event);
+        out.push(event);
+    }
+    chargeBytes(event) {
+        const entryId = timelineEventEntryId(event);
+        if (entryId === null)
+            return;
+        const known = this.entryBytes.get(entryId);
+        const cost = (known === undefined ? 160 : 0) + eventPayloadBytes(event);
+        this.entryBytes.set(entryId, (known ?? 0) + cost);
+        this.approxBytes += cost;
+    }
+    enforceLimits(out, at) {
+        const entries = this.state.entries;
+        let drop = 0;
+        let bytes = this.approxBytes;
+        while (entries.length - drop > 1 &&
+            (entries.length - drop > this.limits.maxEntries || bytes > this.limits.maxBytes)) {
+            bytes -= this.entryBytes.get(entries[drop].id) ?? 0;
+            drop++;
+        }
+        if (drop === 0)
+            return;
+        const throughEntryId = entries[drop - 1].id;
+        for (let i = 0; i < drop; i++) {
+            const id = entries[i].id;
+            this.approxBytes -= this.entryBytes.get(id) ?? 0;
+            this.entryBytes.delete(id);
+        }
+        if (this.approxBytes < 0)
+            this.approxBytes = 0;
+        this.record(out, { kind: 'truncate', at, throughEntryId });
+    }
+}
+export class PmTimelineRegistry {
+    limits;
+    timelines = new Map();
+    constructor(limits = DEFAULT_CHAT_TIMELINE_LIMITS) {
+        this.limits = limits;
+    }
+    getOrCreate(key) {
+        let timeline = this.timelines.get(key);
+        if (!timeline) {
+            timeline = new PmTimeline(this.limits);
+            this.timelines.set(key, timeline);
+        }
+        return timeline;
+    }
+    get(key) {
+        return this.timelines.get(key);
+    }
+    delete(key) {
+        this.timelines.delete(key);
+    }
+    clear() {
+        this.timelines.clear();
+    }
+    usage() {
+        let approxBytes = 0;
+        let entries = 0;
+        for (const timeline of this.timelines.values()) {
+            approxBytes += timeline.byteSize();
+            entries += timeline.entryCount();
+        }
+        return { runs: this.timelines.size, approxBytes, entries };
+    }
+}
+function asRecord(data) {
+    return typeof data === 'object' && data !== null ? data : {};
+}
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function tokenUsage(raw) {
+    return {
+        inputTokens: num(raw.inputTokens) ?? 0,
+        outputTokens: num(raw.outputTokens) ?? 0,
+        cacheCreationTokens: num(raw.cacheCreationTokens) ?? 0,
+        cacheReadTokens: num(raw.cacheReadTokens) ?? 0,
+        currentTurnInputTokens: num(raw.currentTurnInputTokens) ?? 0,
+        ...(raw.isFinal === true ? { isFinal: true } : {}),
+    };
+}
+function clampText(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}\n… [truncated ${text.length - max} chars]`;
+}
+function clampInput(value, max) {
+    const input = asRecord(value);
+    let size;
+    try {
+        size = JSON.stringify(input)?.length ?? 0;
+    }
+    catch {
+        return { _truncated: true };
+    }
+    if (size <= max)
+        return input;
+    return { _truncated: true, _bytes: size };
+}
+function eventPayloadBytes(event) {
+    switch (event.kind) {
+        case 'text':
+        case 'thinking':
+            return event.delta.length;
+        case 'user':
+            return event.text.length;
+        case 'notice':
+            return event.text.length + (event.code?.length ?? 0);
+        case 'tool_use':
+            return event.toolName.length + approxJsonBytes(event.input);
+        case 'tool_result':
+            return event.result.length;
+        default:
+            return 0;
+    }
+}
+function approxJsonBytes(value) {
+    try {
+        return JSON.stringify(value)?.length ?? 0;
+    }
+    catch {
+        return 256;
+    }
+}