@numa-tech/numa 1.12.8 → 1.12.11

package/dist/application-onboarding/tui-model.d.ts

@@ -0,0 +1,131 @@
+import type { JsonValue, OnboardingCapabilities, OnboardingEvent, OnboardingMode, OnboardingPreflight, OnboardingSession } from "./schemas.js";
+export declare const ONBOARDING_STEPS: readonly ["MODE", "BASIC_INFORMATION", "OWNERSHIP", "SOURCE_CONTROL", "TECHNOLOGY", "STANDARDIZATION", "DELIVERY", "REVIEW", "EXECUTION"];
+export type OnboardingStepCode = typeof ONBOARDING_STEPS[number];
+export interface CatalogChoice {
+    value: string;
+    label: string;
+}
+export interface WizardCatalog {
+    connections: Array<Record<string, unknown>>;
+    stacks: Array<Record<string, unknown>>;
+    templates: Array<Record<string, unknown>>;
+    repositories: Array<Record<string, unknown>>;
+    teams: Array<Record<string, unknown>>;
+    systems: Array<Record<string, unknown>>;
+    businessDomains: Array<Record<string, unknown>>;
+    environments: Array<Record<string, unknown>>;
+    errors: string[];
+    repositoryStatus?: string;
+    repositoryNextCursor?: string | null;
+}
+export interface WizardField {
+    path: string;
+    label: string;
+    kind: "text" | "number" | "select" | "boolean" | "json" | "tiers" | "choiceOrText";
+    required?: boolean;
+    choices?: CatalogChoice[];
+    placeholder?: string;
+}
+export interface OnboardingTuiState {
+    phase: "LOADING" | "SELECT_MODE" | "SESSION" | "ERROR";
+    modes: OnboardingMode[];
+    modeIndex: number;
+    session?: OnboardingSession;
+    stepIndex: number;
+    fieldIndex: number;
+    draft: Record<string, unknown>;
+    dirty: boolean;
+    editing: boolean;
+    editBuffer: string;
+    events: OnboardingEvent[];
+    afterSequence: number;
+    catalog: WizardCatalog;
+    preflight?: OnboardingPreflight;
+    assessment?: Record<string, unknown>;
+    busy: boolean;
+    confirmation?: "APPLY" | "CANCEL";
+    idempotencyKey?: string;
+    notice?: string;
+    error?: string;
+}
+export type OnboardingTuiAction = {
+    type: "BOOTSTRAP_LOADED";
+    capabilities: OnboardingCapabilities;
+    catalog: Partial<WizardCatalog>;
+    preferredMode?: OnboardingMode;
+} | {
+    type: "MODE_MOVE";
+    direction: -1 | 1;
+} | {
+    type: "SESSION_LOADED";
+    session: OnboardingSession;
+    preserveStep?: boolean;
+} | {
+    type: "SET_STEP";
+    index: number;
+} | {
+    type: "MOVE_FIELD";
+    direction: -1 | 1;
+    maximum: number;
+} | {
+    type: "START_EDIT";
+    value: string;
+} | {
+    type: "EDIT_BUFFER";
+    value: string;
+} | {
+    type: "STOP_EDIT";
+} | {
+    type: "SET_DRAFT_VALUE";
+    path: string;
+    value: unknown;
+} | {
+    type: "SET_DRAFT";
+    draft: Record<string, unknown>;
+} | {
+    type: "EVENTS_LOADED";
+    events: OnboardingEvent[];
+} | {
+    type: "CATALOG_LOADED";
+    catalog: Partial<WizardCatalog>;
+} | {
+    type: "PREFLIGHT_LOADED";
+    preflight: OnboardingPreflight;
+} | {
+    type: "ASSESSMENT_LOADED";
+    assessment: Record<string, unknown>;
+} | {
+    type: "BUSY";
+    value: boolean;
+    notice?: string;
+} | {
+    type: "CONFIRM";
+    value?: "APPLY" | "CANCEL";
+} | {
+    type: "IDEMPOTENCY_KEY";
+    value: string;
+} | {
+    type: "NOTICE";
+    value: string;
+} | {
+    type: "ERROR";
+    value: string;
+};
+export declare function emptyWizardDraft(mode: OnboardingMode): Record<string, unknown>;
+export declare function initialOnboardingTuiState(): OnboardingTuiState;
+export declare function reduceOnboardingTuiState(state: OnboardingTuiState, action: OnboardingTuiAction): OnboardingTuiState;
+export declare function draftFromSession(session: OnboardingSession): Record<string, unknown>;
+export declare function fieldsForState(state: OnboardingTuiState): WizardField[];
+export declare function valueAtPath(root: Record<string, unknown>, path: string): unknown;
+export declare function stringAt(root: Record<string, unknown>, path: string): string;
+export declare function displayFieldValue(field: WizardField, draft: Record<string, unknown>): string;
+export declare function parseFieldInput(field: WizardField, input: string): unknown;
+export declare function assertCredentialFreeDraft(draft: Record<string, unknown>): void;
+export declare function cycleFieldValue(state: OnboardingTuiState, field: WizardField, direction: -1 | 1): Record<string, unknown>;
+export declare function applyRepositorySelection(draft: Record<string, unknown>, repositories: Array<Record<string, unknown>>, externalId: string): Record<string, unknown>;
+export declare function applyTemplateDefaults(draft: Record<string, unknown>, template: Record<string, unknown> | undefined): Record<string, unknown>;
+export declare function validateTemplateParameters(draft: Record<string, unknown>, templates: Array<Record<string, unknown>>): string[];
+export declare function validateWizardBeforeStep(state: OnboardingTuiState, targetStepIndex: number): string[];
+export declare function currentStepCode(state: OnboardingTuiState): OnboardingStepCode;
+export declare function draftAsJsonValue(draft: Record<string, unknown>): JsonValue;
+export declare function safeTerminalWidth(columns: number | undefined): number;

package/dist/application-onboarding/tui-model.js

@@ -0,0 +1,554 @@
+import { OnboardingError } from "./errors.js";
+import { CredentialFreeOnboardingValueSchema } from "./schemas.js";
+export const ONBOARDING_STEPS = [
+    "MODE",
+    "BASIC_INFORMATION",
+    "OWNERSHIP",
+    "SOURCE_CONTROL",
+    "TECHNOLOGY",
+    "STANDARDIZATION",
+    "DELIVERY",
+    "REVIEW",
+    "EXECUTION"
+];
+export function emptyWizardDraft(mode) {
+    return {
+        schemaVersion: 1,
+        mode,
+        application: { lifecycle: "EXPERIMENTAL", tier: "TIER_3" },
+        repository: { defaultBranch: "main" },
+        technology: { repoMode: "STANDALONE", parameters: {} },
+        delivery: {
+            jenkinsRequired: true,
+            tiers: ["DEVELOP"],
+            gitopsRequired: false,
+            nacosRequired: false
+        }
+    };
+}
+export function initialOnboardingTuiState() {
+    return {
+        phase: "LOADING",
+        modes: ["NEW", "EXISTING"],
+        modeIndex: 0,
+        stepIndex: 0,
+        fieldIndex: 0,
+        draft: emptyWizardDraft("NEW"),
+        dirty: false,
+        editing: false,
+        editBuffer: "",
+        events: [],
+        afterSequence: 0,
+        catalog: {
+            connections: [],
+            stacks: [],
+            templates: [],
+            repositories: [],
+            teams: [],
+            systems: [],
+            businessDomains: [],
+            environments: [],
+            errors: []
+        },
+        busy: false
+    };
+}
+export function reduceOnboardingTuiState(state, action) {
+    switch (action.type) {
+        case "BOOTSTRAP_LOADED": {
+            const supported = action.capabilities.supportedModes ?? action.capabilities.modes;
+            const modes = supported?.length ? supported : ["NEW", "EXISTING"];
+            const preferredIndex = action.preferredMode == null ? -1 : modes.indexOf(action.preferredMode);
+            const selectedIndex = Math.max(0, preferredIndex);
+            return {
+                ...state,
+                phase: "SELECT_MODE",
+                modes,
+                modeIndex: selectedIndex,
+                draft: emptyWizardDraft(modes[selectedIndex] ?? "NEW"),
+                catalog: mergeCatalog(state.catalog, action.catalog),
+                busy: false,
+                error: undefined
+            };
+        }
+        case "MODE_MOVE": {
+            const modeIndex = Math.min(state.modes.length - 1, Math.max(0, state.modeIndex + action.direction));
+            return { ...state, modeIndex, draft: emptyWizardDraft(state.modes[modeIndex] ?? "NEW") };
+        }
+        case "SESSION_LOADED": {
+            const serverStep = stepIndexForSession(action.session);
+            return {
+                ...state,
+                phase: "SESSION",
+                session: action.session,
+                stepIndex: action.preserveStep ? state.stepIndex : serverStep,
+                fieldIndex: 0,
+                draft: draftFromSession(action.session),
+                dirty: false,
+                editing: false,
+                editBuffer: "",
+                busy: false,
+                confirmation: undefined,
+                error: undefined
+            };
+        }
+        case "SET_STEP":
+            return {
+                ...state,
+                stepIndex: clamp(action.index, 0, ONBOARDING_STEPS.length - 1),
+                fieldIndex: 0,
+                editing: false,
+                editBuffer: ""
+            };
+        case "MOVE_FIELD":
+            return { ...state, fieldIndex: clamp(state.fieldIndex + action.direction, 0, Math.max(0, action.maximum - 1)) };
+        case "START_EDIT":
+            return { ...state, editing: true, editBuffer: action.value, error: undefined };
+        case "EDIT_BUFFER":
+            return { ...state, editBuffer: action.value.slice(0, 16_384) };
+        case "STOP_EDIT":
+            return { ...state, editing: false, editBuffer: "" };
+        case "SET_DRAFT_VALUE":
+            return changedDraft(state, setDraftPath(state.draft, action.path, action.value));
+        case "SET_DRAFT":
+            return changedDraft(state, action.draft);
+        case "EVENTS_LOADED": {
+            const bySequence = new Map(state.events.map((event) => [event.sequenceNo, event]));
+            for (const event of action.events) {
+                if (event.sequenceNo > state.afterSequence)
+                    bySequence.set(event.sequenceNo, event);
+            }
+            const events = [...bySequence.values()].sort((left, right) => left.sequenceNo - right.sequenceNo);
+            return {
+                ...state,
+                events,
+                afterSequence: events.reduce((maximum, event) => Math.max(maximum, event.sequenceNo), state.afterSequence)
+            };
+        }
+        case "CATALOG_LOADED":
+            return { ...state, catalog: mergeCatalog(state.catalog, action.catalog), busy: false };
+        case "PREFLIGHT_LOADED":
+            return { ...state, preflight: action.preflight, busy: false, error: undefined };
+        case "ASSESSMENT_LOADED":
+            return { ...state, assessment: action.assessment, busy: false, error: undefined };
+        case "BUSY":
+            return { ...state, busy: action.value, notice: action.notice ?? state.notice, error: undefined };
+        case "CONFIRM":
+            return { ...state, confirmation: action.value };
+        case "IDEMPOTENCY_KEY":
+            return { ...state, idempotencyKey: action.value };
+        case "NOTICE":
+            return { ...state, notice: action.value, busy: false, error: undefined };
+        case "ERROR":
+            return { ...state, phase: state.session ? "SESSION" : "ERROR", error: action.value, busy: false };
+    }
+}
+function changedDraft(state, draft) {
+    return {
+        ...state,
+        draft,
+        dirty: true,
+        editing: false,
+        editBuffer: "",
+        preflight: undefined,
+        idempotencyKey: undefined,
+        confirmation: undefined,
+        error: undefined
+    };
+}
+function mergeCatalog(current, update) {
+    return {
+        connections: update.connections ?? current.connections,
+        stacks: update.stacks ?? current.stacks,
+        templates: update.templates ?? current.templates,
+        repositories: update.repositories ?? current.repositories,
+        teams: update.teams ?? current.teams,
+        systems: update.systems ?? current.systems,
+        businessDomains: update.businessDomains ?? current.businessDomains,
+        environments: update.environments ?? current.environments,
+        errors: update.errors ?? current.errors,
+        repositoryStatus: update.repositoryStatus ?? current.repositoryStatus,
+        repositoryNextCursor: update.repositoryNextCursor !== undefined
+            ? update.repositoryNextCursor
+            : current.repositoryNextCursor
+    };
+}
+export function draftFromSession(session) {
+    const base = emptyWizardDraft(session.mode);
+    if (!session.draft || typeof session.draft !== "object" || Array.isArray(session.draft))
+        return base;
+    const incoming = cloneObject(session.draft);
+    return {
+        ...base,
+        ...incoming,
+        schemaVersion: typeof incoming.schemaVersion === "number" ? incoming.schemaVersion : 1,
+        mode: session.mode,
+        application: { ...asObject(base.application), ...asObject(incoming.application) },
+        repository: { ...asObject(base.repository), ...asObject(incoming.repository) },
+        technology: { ...asObject(base.technology), ...asObject(incoming.technology) },
+        delivery: { ...asObject(base.delivery), ...asObject(incoming.delivery) }
+    };
+}
+export function fieldsForState(state) {
+    const step = ONBOARDING_STEPS[state.stepIndex];
+    const mode = state.session?.mode ?? state.modes[state.modeIndex] ?? "NEW";
+    if (step === "BASIC_INFORMATION")
+        return [
+            { path: "application.code", label: "Application code", kind: "text", required: true, placeholder: "order-service" },
+            { path: "application.name", label: "Application name", kind: "text", required: true },
+            { path: "application.description", label: "Description", kind: "text" },
+            { path: "application.lifecycle", label: "Lifecycle", kind: "select", choices: choices(["EXPERIMENTAL", "PRODUCTION", "DEPRECATED"]) },
+            { path: "application.tier", label: "Application tier", kind: "text", placeholder: "TIER_3" }
+        ];
+    if (step === "OWNERSHIP")
+        return [
+            { path: "application.teamId", label: "Team ID", kind: "number", required: true, choices: entityChoices(state.catalog.teams) },
+            { path: "application.systemId", label: "System ID", kind: "number", required: true, choices: entityChoices(state.catalog.systems) },
+            { path: "application.businessDomainId", label: "Business domain ID", kind: "number", choices: entityChoices(state.catalog.businessDomains) },
+            { path: "application.defaultEnvironmentId", label: "Default environment ID", kind: "number", choices: entityChoices(state.catalog.environments) },
+            { path: "application.ownerUsername", label: "Owner username", kind: "text" }
+        ];
+    if (step === "SOURCE_CONTROL") {
+        const connectionChoices = state.catalog.connections.map((item) => ({
+            value: text(item.code),
+            label: [text(item.name), text(item.provider), text(item.health)].filter(Boolean).join(" · ")
+        })).filter((item) => item.value);
+        const common = [{
+                path: "repository.connectionCode",
+                label: "SCM connection",
+                kind: "select",
+                required: true,
+                choices: includeCurrent(connectionChoices, stringAt(state.draft, "repository.connectionCode"))
+            }];
+        const addModule = mode === "NEW" && stringAt(state.draft, "technology.repoMode") === "ADD_MODULE";
+        if (mode === "NEW" && !addModule)
+            return [...common,
+                { path: "repository.namespace", label: "Organization / namespace", kind: "text", required: true },
+                { path: "repository.name", label: "Repository name", kind: "text", required: true },
+                { path: "repository.defaultBranch", label: "Default branch", kind: "text" }
+            ];
+        const repositoryChoices = state.catalog.repositories.map((item) => ({
+            value: text(item.externalId ?? item.id),
+            label: text(item.fullName ?? item.name ?? item.externalId ?? item.id)
+        })).filter((item) => item.value);
+        return [...common,
+            {
+                path: "repository.externalId",
+                label: "Existing repository external ID",
+                kind: "choiceOrText",
+                required: true,
+                choices: includeCurrent(repositoryChoices, stringAt(state.draft, "repository.externalId"))
+            },
+            { path: "repository.expectedHead", label: "Expected repository HEAD", kind: "text", required: true, placeholder: "immutable commit SHA" },
+            { path: "repository.defaultBranch", label: "Default branch", kind: "text" }
+        ];
+    }
+    if (step === "TECHNOLOGY") {
+        const stackChoices = state.catalog.stacks.map((item) => ({ value: text(item.code), label: stackLabel(item) })).filter((item) => item.value);
+        const stackCode = stringAt(state.draft, "technology.stackCode");
+        const repoMode = stringAt(state.draft, "technology.repoMode");
+        const templates = state.catalog.templates.filter((item) => (!stackCode || text(item.technologyStackCode) === stackCode)
+            && (!repoMode || !text(item.repoMode) || text(item.repoMode) === repoMode));
+        const templateChoices = templates.map((item) => ({ value: text(item.code), label: templateLabel(item) })).filter((item) => item.value);
+        return [
+            {
+                path: "technology.stackCode",
+                label: "Standard technology stack",
+                kind: "select",
+                required: true,
+                choices: includeCurrent(stackChoices, stackCode)
+            },
+            { path: "technology.repoMode", label: "Repository mode", kind: "select", choices: choices(["STANDALONE", "ADD_MODULE"]) },
+            ...(mode === "NEW" ? [{
+                    path: "technology.templateCode",
+                    label: "Copier template",
+                    kind: "select",
+                    required: true,
+                    choices: includeCurrent(templateChoices, stringAt(state.draft, "technology.templateCode"))
+                }] : []),
+            { path: "technology.parameters", label: "Template parameters JSON", kind: "json" }
+        ];
+    }
+    if (step === "DELIVERY")
+        return [
+            { path: "delivery.jenkinsRequired", label: "Jenkins required", kind: "boolean" },
+            { path: "delivery.tiers", label: "Jenkins tiers", kind: "tiers" },
+            { path: "delivery.gitopsRequired", label: "GitOps required", kind: "boolean" },
+            { path: "delivery.nacosRequired", label: "Nacos required", kind: "boolean" }
+        ];
+    return [];
+}
+export function valueAtPath(root, path) {
+    let current = root;
+    for (const part of path.split(".")) {
+        if (!current || typeof current !== "object" || Array.isArray(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+export function stringAt(root, path) {
+    const value = valueAtPath(root, path);
+    return typeof value === "string" ? value : value == null ? "" : String(value);
+}
+export function displayFieldValue(field, draft) {
+    const value = valueAtPath(draft, field.path);
+    if (field.kind === "boolean")
+        return value === true ? "yes" : "no";
+    if (field.kind === "json")
+        return JSON.stringify(value ?? {}, null, 0);
+    if (field.kind === "tiers")
+        return Array.isArray(value) ? value.join(",") : "";
+    if (value == null || value === "")
+        return field.placeholder ? `<${field.placeholder}>` : "—";
+    const raw = String(value);
+    const choice = field.choices?.find((item) => item.value === raw);
+    return choice ? `${choice.value} · ${choice.label}` : raw;
+}
+export function parseFieldInput(field, input) {
+    const trimmed = input.trim();
+    if (field.kind === "number") {
+        if (!trimmed)
+            return undefined;
+        const parsed = Number(trimmed);
+        if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+            throw new OnboardingError(`${field.label} must be a positive integer.`, "onboarding_input_invalid");
+        }
+        return parsed;
+    }
+    if (field.kind === "json") {
+        if (!trimmed)
+            return {};
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (error) {
+            throw new OnboardingError(`${field.label} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`, "onboarding_input_invalid");
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new OnboardingError(`${field.label} must be a JSON object.`, "onboarding_input_invalid");
+        }
+        return parsed;
+    }
+    if (field.kind === "tiers") {
+        const tiers = [...new Set(trimmed.split(",").map((item) => item.trim().toUpperCase()).filter(Boolean))];
+        if (tiers.some((tier) => !["DEVELOP", "STAGING", "PRODUCTION"].includes(tier))) {
+            throw new OnboardingError("Jenkins tiers must be DEVELOP, STAGING, or PRODUCTION.", "onboarding_input_invalid");
+        }
+        return tiers;
+    }
+    if (/[\u0000-\u001f\u007f]/u.test(input)) {
+        throw new OnboardingError(`${field.label} contains control characters.`, "onboarding_input_invalid");
+    }
+    return trimmed || undefined;
+}
+export function assertCredentialFreeDraft(draft) {
+    const parsed = CredentialFreeOnboardingValueSchema.safeParse(draft);
+    if (!parsed.success) {
+        throw new OnboardingError(`Draft contains credential-bearing input: ${parsed.error.issues[0]?.path.join(".") || "unknown field"}.`, "onboarding_secret_not_allowed");
+    }
+}
+export function cycleFieldValue(state, field, direction) {
+    if (field.kind === "boolean") {
+        return setDraftPath(state.draft, field.path, valueAtPath(state.draft, field.path) !== true);
+    }
+    const options = field.choices ?? [];
+    if (!options.length)
+        return state.draft;
+    const current = stringAt(state.draft, field.path);
+    const currentIndex = options.findIndex((option) => option.value === current);
+    const nextIndex = currentIndex < 0
+        ? direction > 0 ? 0 : options.length - 1
+        : (currentIndex + direction + options.length) % options.length;
+    const selected = options[nextIndex].value;
+    return setDraftPath(state.draft, field.path, field.kind === "number" ? Number(selected) : selected);
+}
+export function applyRepositorySelection(draft, repositories, externalId) {
+    let result = setDraftPath(draft, "repository.externalId", externalId || undefined);
+    const repository = repositories.find((item) => text(item.externalId ?? item.id) === externalId);
+    if (!repository)
+        return result;
+    result = setDraftPath(result, "repository.expectedHead", text(repository.headRevision) || undefined);
+    result = setDraftPath(result, "repository.name", text(repository.name) || undefined);
+    result = setDraftPath(result, "repository.namespace", undefined);
+    return setDraftPath(result, "repository.defaultBranch", text(repository.defaultBranch) || "main");
+}
+export function applyTemplateDefaults(draft, template) {
+    const schema = asObject(template?.parameterSchema);
+    const defaults = defaultsFromSchema(schema);
+    return setDraftPath(draft, "technology.parameters", defaults);
+}
+export function validateTemplateParameters(draft, templates) {
+    const templateCode = stringAt(draft, "technology.templateCode");
+    const template = templates.find((item) => text(item.code) === templateCode);
+    if (!template)
+        return templateCode ? ["Selected template is not in the active template catalog."] : ["Select a template."];
+    const schema = asObject(template.parameterSchema);
+    const parameters = asObject(valueAtPath(draft, "technology.parameters"));
+    return validateSchemaObject(schema, parameters, "technology.parameters");
+}
+export function validateWizardBeforeStep(state, targetStepIndex) {
+    if (targetStepIndex < ONBOARDING_STEPS.indexOf("STANDARDIZATION"))
+        return [];
+    const errors = [];
+    const mode = state.session?.mode ?? state.modes[state.modeIndex] ?? "NEW";
+    const requireText = (path) => {
+        if (!stringAt(state.draft, path).trim())
+            errors.push(`${path} is required.`);
+    };
+    requireText("application.code");
+    requireText("application.name");
+    if (!positiveIntegerAt(state.draft, "application.teamId"))
+        errors.push("application.teamId must be a positive integer.");
+    if (!positiveIntegerAt(state.draft, "application.systemId"))
+        errors.push("application.systemId must be a positive integer.");
+    requireText("repository.connectionCode");
+    const addModule = mode === "NEW" && stringAt(state.draft, "technology.repoMode") === "ADD_MODULE";
+    if (mode === "NEW" && !addModule) {
+        requireText("repository.namespace");
+        requireText("repository.name");
+    }
+    else {
+        requireText("repository.externalId");
+        requireText("repository.expectedHead");
+    }
+    requireText("technology.stackCode");
+    if (mode === "NEW") {
+        requireText("technology.templateCode");
+        const selected = state.catalog.templates.find((item) => text(item.code) === stringAt(state.draft, "technology.templateCode"));
+        if (selected)
+            errors.push(...validateTemplateParameters(state.draft, state.catalog.templates));
+    }
+    return [...new Set(errors)];
+}
+function validateSchemaObject(schema, value, path) {
+    const errors = [];
+    const required = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
+    for (const key of required) {
+        if (value[key] == null || value[key] === "")
+            errors.push(`${path}.${key} is required.`);
+    }
+    for (const [key, propertyValue] of Object.entries(asObject(schema.properties))) {
+        if (value[key] == null)
+            continue;
+        const property = asObject(propertyValue);
+        const expected = text(property.type);
+        const actual = value[key];
+        if (expected === "string" && typeof actual !== "string")
+            errors.push(`${path}.${key} must be a string.`);
+        if ((expected === "integer" && (!Number.isInteger(actual) || typeof actual !== "number"))
+            || (expected === "number" && typeof actual !== "number"))
+            errors.push(`${path}.${key} must be a ${expected}.`);
+        if (expected === "boolean" && typeof actual !== "boolean")
+            errors.push(`${path}.${key} must be a boolean.`);
+        if (expected === "array" && !Array.isArray(actual))
+            errors.push(`${path}.${key} must be an array.`);
+        if (expected === "object" && (!actual || typeof actual !== "object" || Array.isArray(actual)))
+            errors.push(`${path}.${key} must be an object.`);
+        if (Array.isArray(property.enum) && !property.enum.some((item) => JSON.stringify(item) === JSON.stringify(actual))) {
+            errors.push(`${path}.${key} must be one of ${property.enum.map(String).join(", ")}.`);
+        }
+        if (typeof property.pattern === "string" && typeof actual === "string") {
+            try {
+                if (!new RegExp(property.pattern, "u").test(actual))
+                    errors.push(`${path}.${key} does not match the template pattern.`);
+            }
+            catch {
+                errors.push(`${path}.${key} has an invalid registry pattern.`);
+            }
+        }
+    }
+    return errors;
+}
+function defaultsFromSchema(schema) {
+    const result = {};
+    for (const [key, value] of Object.entries(asObject(schema.properties))) {
+        const property = asObject(value);
+        if (property.default !== undefined)
+            result[key] = cloneValue(property.default);
+    }
+    return result;
+}
+export function currentStepCode(state) {
+    return ONBOARDING_STEPS[state.stepIndex] ?? "BASIC_INFORMATION";
+}
+function stepIndexForSession(session) {
+    const known = ONBOARDING_STEPS.indexOf(session.currentStep);
+    if (known >= 0)
+        return known;
+    return ["RUNNING", "WAITING_EXTERNAL", "VERIFYING", "COMPLETED", "FAILED", "CANCELLED"].includes(session.state)
+        ? ONBOARDING_STEPS.length - 1
+        : 1;
+}
+function setDraftPath(root, path, value) {
+    const result = cloneObject(root);
+    const parts = path.split(".");
+    let current = result;
+    for (const part of parts.slice(0, -1)) {
+        current[part] = asObject(current[part]);
+        current = current[part];
+    }
+    const leaf = parts[parts.length - 1];
+    if (value === undefined)
+        delete current[leaf];
+    else
+        current[leaf] = cloneValue(value);
+    return result;
+}
+function cloneObject(value) {
+    return cloneValue(value);
+}
+function cloneValue(value) {
+    if (Array.isArray(value))
+        return value.map(cloneValue);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneValue(item)]));
+    }
+    return value;
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? cloneObject(value) : {};
+}
+function text(value) {
+    return typeof value === "string" ? value : typeof value === "number" ? String(value) : "";
+}
+function choices(values) {
+    return values.map((value) => ({ value, label: value }));
+}
+function includeCurrent(options, current) {
+    return current && !options.some((item) => item.value === current)
+        ? [{ value: current, label: `${current} (saved value)` }, ...options]
+        : options;
+}
+function stackLabel(item) {
+    return [text(item.name), text(item.language), text(item.framework), text(item.runtimeVersion)].filter(Boolean).join(" · ");
+}
+function templateLabel(item) {
+    return [text(item.name), text(item.sourceRevision), text(item.repoMode)].filter(Boolean).join(" · ");
+}
+function entityChoices(items) {
+    return items.flatMap((item) => {
+        const value = text(item.id ?? item.value);
+        if (!value)
+            return [];
+        return [{
+                value,
+                label: [text(item.name ?? item.label), text(item.code), text(item.status)].filter(Boolean).join(" · ")
+            }];
+    });
+}
+function positiveIntegerAt(root, path) {
+    const value = valueAtPath(root, path);
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}
+export function draftAsJsonValue(draft) {
+    return draft;
+}
+export function safeTerminalWidth(columns) {
+    return columns != null && Number.isFinite(columns) && columns > 0 ? Math.floor(columns) : 100;
+}
+//# sourceMappingURL=tui-model.js.map