@spekn/cli 1.0.1 → 1.0.2

package/dist/tui/services/context-service.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuiContextService = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const shared_enums_1 = require("../shared-enums");
+const credentials_store_1 = require("../../auth/credentials-store");
+const client_1 = require("./client");
+const DEFAULT_BRIDGE_CONFIG = {
+    port: 19550,
+    pairing: null,
+};
+function loadLocalBridgeConfig() {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), '.spekn', 'bridge', 'config.json');
+    try {
+        const raw = node_fs_1.default.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            port: typeof parsed.port === 'number' ? parsed.port : DEFAULT_BRIDGE_CONFIG.port,
+            pairing: parsed.pairing ?? DEFAULT_BRIDGE_CONFIG.pairing,
+        };
+    }
+    catch {
+        return DEFAULT_BRIDGE_CONFIG;
+    }
+}
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const base64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+        const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+        const json = Buffer.from(padded, 'base64').toString('utf-8');
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizePlan(raw) {
+    if (raw === shared_enums_1.OrganizationPlan.PRO)
+        return shared_enums_1.OrganizationPlan.PRO;
+    if (raw === shared_enums_1.OrganizationPlan.TEAM)
+        return shared_enums_1.OrganizationPlan.TEAM;
+    if (raw === shared_enums_1.OrganizationPlan.ENTERPRISE)
+        return shared_enums_1.OrganizationPlan.ENTERPRISE;
+    return shared_enums_1.OrganizationPlan.FREE;
+}
+function normalizeRole(raw) {
+    if (raw === 'owner' || raw === 'admin' || raw === 'member' || raw === 'viewer') {
+        return raw;
+    }
+    return 'member';
+}
+class TuiContextService {
+    apiUrl;
+    credentialsStore = new credentials_store_1.CredentialsStore();
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+    async bootstrap(projectIdArg) {
+        const token = await this.credentialsStore.getValidToken();
+        if (!token) {
+            throw new Error('No valid credentials. Run `spekn auth login` first.');
+        }
+        const claims = decodeJwtPayload(token);
+        const permissions = Array.isArray(claims?.permissions)
+            ? claims?.permissions.filter((item) => typeof item === 'string')
+            : [];
+        const stored = this.credentialsStore.load();
+        const fallbackOrg = stored?.organizationId ?? process.env.SPEKN_ORGANIZATION_ID ?? '';
+        const bootstrapClient = (0, client_1.createApiClient)(this.apiUrl, token, fallbackOrg);
+        const orgs = await bootstrapClient.organization.list.query();
+        if (orgs.length === 0) {
+            throw new Error('No organization membership found for this account.');
+        }
+        const org = orgs.find((candidate) => candidate.id === fallbackOrg) ?? orgs[0];
+        const organizationId = org.id;
+        const client = (0, client_1.createApiClient)(this.apiUrl, token, organizationId);
+        const projects = await client.project.list.query({
+            limit: 20,
+            offset: 0,
+        });
+        if (projects.length === 0) {
+            throw new Error('No projects found for this organization. Create one in Spekn first.');
+        }
+        const project = projects.find((candidate) => candidate.id === projectIdArg) ?? projects[0];
+        return {
+            boot: {
+                apiUrl: this.apiUrl,
+                organizationId,
+                organizationName: org.name,
+                role: normalizeRole(org.role),
+                plan: normalizePlan(org.plan),
+                projectId: project.id,
+                projectName: project.name,
+                permissions,
+            },
+            client,
+        };
+    }
+    async loadSpecs(client, projectId) {
+        const specs = await client.specification.list.query({
+            projectId,
+            limit: 50,
+            offset: 0,
+        });
+        return (Array.isArray(specs) ? specs : []).map((spec) => ({
+            id: spec.id,
+            title: spec.title,
+            status: spec.status,
+            version: spec.version,
+            updatedAt: spec.updatedAt,
+            type: spec.frontmatter?.type,
+        }));
+    }
+    async loadDecisions(client, projectId) {
+        const result = await client.decision.getAll.query({
+            projectId,
+            limit: 50,
+            offset: 0,
+        });
+        const decisions = Array.isArray(result?.decisions) ? result.decisions : [];
+        return decisions.map((decision) => ({
+            id: decision.id,
+            title: decision.title,
+            status: decision.status,
+            decisionType: decision.decisionType,
+            specAnchor: decision.specAnchor,
+            createdAt: decision.createdAt,
+        }));
+    }
+    async loadWorkflowSummary(client, projectId) {
+        const states = await client.workflowState.listByProject.query({ projectId });
+        const first = Array.isArray(states) && states.length > 0 ? states[0] : null;
+        const currentPhase = first?.currentPhase ?? null;
+        const blockedCount = Array.isArray(states)
+            ? states.filter((state) => state.specificationLockStatus === 'locked').length
+            : 0;
+        return {
+            currentPhase,
+            blockedCount,
+            hasVerificationEvidence: Boolean(first?.hasVerificationEvidence),
+            hasPlanningArtifacts: Boolean(first?.hasPlanningArtifacts),
+        };
+    }
+    async previewExport(client, projectId, format) {
+        const result = await client.export.preview.query({
+            projectId,
+            formatId: format,
+        });
+        return {
+            content: String(result.content ?? ''),
+            anchorCount: Number(result.anchorCount ?? 0),
+            specVersion: typeof result.specVersion === 'string' ? result.specVersion : undefined,
+            warnings: Array.isArray(result.warnings)
+                ? result.warnings.filter((warning) => typeof warning === 'string')
+                : undefined,
+        };
+    }
+    async generateExport(client, projectId, format) {
+        const result = await client.export.generate.mutate({
+            projectId,
+            formatId: format,
+        });
+        return {
+            content: String(result.content ?? ''),
+            anchorCount: Number(result.anchorCount ?? 0),
+            specVersion: typeof result.specVersion === 'string' ? result.specVersion : undefined,
+            warnings: Array.isArray(result.warnings)
+                ? result.warnings.filter((warning) => typeof warning === 'string')
+                : undefined,
+        };
+    }
+    async loadBridgeSummary(client) {
+        const [flag, devices, metrics] = await Promise.all([
+            client.bridge.getFeatureFlag.query().catch(() => ({ enabled: false })),
+            client.bridge.listDevices.query().catch(() => []),
+            client.bridge.getMetrics.query().catch(() => ({ connectedDevices: 0, authFailures: 0 })),
+        ]);
+        return {
+            featureEnabled: Boolean(flag.enabled),
+            devices: Array.isArray(devices)
+                ? devices.map((device) => ({
+                    id: device.id,
+                    name: device.name,
+                    status: device.status,
+                    isDefault: Boolean(device.isDefault),
+                    lastSeenAt: device.lastSeenAt,
+                }))
+                : [],
+            connectedDevices: Number(metrics.connectedDevices ?? 0),
+            authFailures: Number(metrics.authFailures ?? 0),
+        };
+    }
+    async loadLocalBridgeSummary() {
+        const config = loadLocalBridgeConfig();
+        let running = false;
+        let uptimeSec;
+        try {
+            const response = await fetch(`http://127.0.0.1:${config.port}/health`);
+            if (response.ok) {
+                const payload = (await response.json());
+                running = true;
+                uptimeSec = Number(payload.uptime ?? 0);
+            }
+        }
+        catch {
+            running = false;
+        }
+        return {
+            paired: config.pairing !== null,
+            deviceId: config.pairing?.deviceId,
+            deviceName: config.pairing?.deviceName,
+            port: config.port,
+            running,
+            uptimeSec,
+        };
+    }
+    startLocalBridgeDetached() {
+        const args = [process.argv[1] ?? '', 'bridge', 'start'];
+        const child = (0, node_child_process_1.spawn)(process.execPath, args, {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+    async stopLocalBridge(configPort) {
+        const port = configPort ?? this.bridgeConfigStore.get().port;
+        try {
+            await fetch(`http://127.0.0.1:${port}/shutdown`, {
+                method: 'POST',
+            });
+        }
+        catch {
+            // best effort; bridge may already be down
+        }
+    }
+}
+exports.TuiContextService = TuiContextService;

package/dist/tui/shared-enums.d.ts

@@ -0,0 +1,16 @@
+export declare const OrganizationPlan: {
+    readonly FREE: "free";
+    readonly PRO: "pro";
+    readonly TEAM: "team";
+    readonly ENTERPRISE: "enterprise";
+};
+export type OrganizationPlan = (typeof OrganizationPlan)[keyof typeof OrganizationPlan];
+export declare const WorkflowPhase: {
+    readonly SPECIFY: "specify";
+    readonly CLARIFY: "clarify";
+    readonly PLAN: "plan";
+    readonly IMPLEMENT: "implement";
+    readonly VERIFY: "verify";
+    readonly COMPLETE: "complete";
+};
+export type WorkflowPhase = (typeof WorkflowPhase)[keyof typeof WorkflowPhase];

package/dist/tui/shared-enums.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowPhase = exports.OrganizationPlan = void 0;
+// Keep lightweight enum values local to the TUI bundle so we don't pull
+// @spekn/shared's TypeORM-backed index into ESM runtime code.
+exports.OrganizationPlan = {
+    FREE: 'free',
+    PRO: 'pro',
+    TEAM: 'team',
+    ENTERPRISE: 'enterprise',
+};
+exports.WorkflowPhase = {
+    SPECIFY: 'specify',
+    CLARIFY: 'clarify',
+    PLAN: 'plan',
+    IMPLEMENT: 'implement',
+    VERIFY: 'verify',
+    COMPLETE: 'complete',
+};

package/dist/tui/state/use-app-state.d.ts

@@ -0,0 +1,35 @@
+import type { BridgeSummary, DecisionListItem, ExportFormat, ExportPreview, LocalBridgeSummary, NavItemPolicy, SpecListItem, TuiBootContext, TuiScreenId, WorkflowSummary } from '../types';
+export interface TuiState {
+    boot: TuiBootContext | null;
+    client: any | null;
+    loading: boolean;
+    error: string | null;
+    screen: TuiScreenId;
+    navPolicy: NavItemPolicy[];
+    specs: SpecListItem[];
+    decisions: DecisionListItem[];
+    workflow: WorkflowSummary;
+    bridge: BridgeSummary | null;
+    localBridge: LocalBridgeSummary | null;
+    exportFormat: ExportFormat;
+    exportPreview: ExportPreview | null;
+    statusLine: string;
+    logs: string[];
+    searchQuery: string;
+    showHelp: boolean;
+    commandMode: boolean;
+}
+export declare function useAppState(apiUrl: string, initialScreen: TuiScreenId, projectId?: string): {
+    state: TuiState;
+    refresh: () => Promise<void>;
+    setScreen: (screen: TuiScreenId) => void;
+    toggleHelp: () => void;
+    setSearchQuery: (searchQuery: string) => void;
+    setCommandMode: (commandMode: boolean) => void;
+    setExportFormat: (exportFormat: ExportFormat) => void;
+    previewExport: () => Promise<void>;
+    generateExport: () => Promise<void>;
+    bridgeStart: () => void;
+    bridgeStop: () => Promise<void>;
+    appendLog: (entry: string) => void;
+};

package/dist/tui/state/use-app-state.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppState = useAppState;
+const react_1 = require("react");
+const policy_1 = require("../capabilities/policy");
+const context_service_1 = require("../services/context-service");
+const EMPTY_WORKFLOW = {
+    currentPhase: null,
+    blockedCount: 0,
+    hasPlanningArtifacts: false,
+    hasVerificationEvidence: false,
+};
+function useAppState(apiUrl, initialScreen, projectId) {
+    const service = (0, react_1.useMemo)(() => new context_service_1.TuiContextService(apiUrl), [apiUrl]);
+    const [state, setState] = (0, react_1.useState)({
+        boot: null,
+        client: null,
+        loading: true,
+        error: null,
+        screen: initialScreen,
+        navPolicy: [],
+        specs: [],
+        decisions: [],
+        workflow: EMPTY_WORKFLOW,
+        bridge: null,
+        localBridge: null,
+        exportFormat: 'claude-md',
+        exportPreview: null,
+        statusLine: 'Bootstrapping...',
+        logs: [],
+        searchQuery: '',
+        showHelp: false,
+        commandMode: false,
+    });
+    const appendLog = (0, react_1.useCallback)((entry) => {
+        setState((prev) => ({ ...prev, logs: [entry, ...prev.logs].slice(0, 40) }));
+    }, []);
+    const refresh = (0, react_1.useCallback)(async () => {
+        setState((prev) => ({ ...prev, loading: true, statusLine: 'Loading context...' }));
+        try {
+            const { boot, client } = await service.bootstrap(projectId);
+            const [specs, decisions, workflow, bridge, localBridge] = await Promise.all([
+                service.loadSpecs(client, boot.projectId),
+                service.loadDecisions(client, boot.projectId),
+                service.loadWorkflowSummary(client, boot.projectId),
+                service.loadBridgeSummary(client),
+                service.loadLocalBridgeSummary(),
+            ]);
+            const capabilityContext = {
+                plan: boot.plan,
+                role: boot.role,
+                workflowPhase: workflow.currentPhase,
+                permissions: boot.permissions,
+            };
+            const navPolicy = (0, policy_1.resolveNavPolicy)(capabilityContext);
+            setState((prev) => ({
+                ...prev,
+                boot,
+                client,
+                specs,
+                decisions,
+                workflow,
+                bridge,
+                localBridge,
+                navPolicy,
+                loading: false,
+                error: null,
+                statusLine: 'Ready',
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            setState((prev) => ({ ...prev, loading: false, error: message, statusLine: 'Error' }));
+            appendLog(`[error] ${message}`);
+        }
+    }, [appendLog, projectId, service]);
+    (0, react_1.useEffect)(() => {
+        void refresh();
+    }, [refresh]);
+    (0, react_1.useEffect)(() => {
+        const timer = setInterval(() => {
+            if (!state.client || !state.boot)
+                return;
+            void Promise.all([
+                service.loadWorkflowSummary(state.client, state.boot.projectId),
+                service.loadLocalBridgeSummary(),
+            ])
+                .then(([workflow, localBridge]) => {
+                setState((prev) => {
+                    const ctx = {
+                        plan: prev.boot?.plan ?? prev.navPolicy[0]?.requiredPlan ?? (prev.boot?.plan ?? 'free'),
+                        role: prev.boot?.role ?? 'member',
+                        workflowPhase: workflow.currentPhase,
+                        permissions: prev.boot?.permissions ?? [],
+                    };
+                    return {
+                        ...prev,
+                        workflow,
+                        localBridge,
+                        navPolicy: (0, policy_1.resolveNavPolicy)(ctx),
+                    };
+                });
+            })
+                .catch(() => undefined);
+        }, 6000);
+        return () => clearInterval(timer);
+    }, [service, state.boot, state.client, state.navPolicy]);
+    const setScreen = (0, react_1.useCallback)((screen) => {
+        setState((prev) => ({ ...prev, screen }));
+    }, []);
+    const toggleHelp = (0, react_1.useCallback)(() => {
+        setState((prev) => ({ ...prev, showHelp: !prev.showHelp }));
+    }, []);
+    const setSearchQuery = (0, react_1.useCallback)((searchQuery) => {
+        setState((prev) => ({ ...prev, searchQuery }));
+    }, []);
+    const setCommandMode = (0, react_1.useCallback)((commandMode) => {
+        setState((prev) => ({ ...prev, commandMode }));
+    }, []);
+    const setExportFormat = (0, react_1.useCallback)((exportFormat) => {
+        setState((prev) => ({ ...prev, exportFormat }));
+    }, []);
+    const previewExport = (0, react_1.useCallback)(async () => {
+        if (!state.client || !state.boot)
+            return;
+        setState((prev) => ({ ...prev, statusLine: 'Previewing export...' }));
+        try {
+            const preview = await service.previewExport(state.client, state.boot.projectId, state.exportFormat);
+            setState((prev) => ({ ...prev, exportPreview: preview, statusLine: 'Export preview ready' }));
+            appendLog(`[export] Previewed ${state.exportFormat} (${preview.anchorCount} anchors)`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendLog(`[error] Export preview failed: ${message}`);
+            setState((prev) => ({ ...prev, statusLine: 'Export preview failed' }));
+        }
+    }, [appendLog, service, state.boot, state.client, state.exportFormat]);
+    const generateExport = (0, react_1.useCallback)(async () => {
+        if (!state.client || !state.boot)
+            return;
+        setState((prev) => ({ ...prev, statusLine: 'Generating export...' }));
+        try {
+            const output = await service.generateExport(state.client, state.boot.projectId, state.exportFormat);
+            setState((prev) => ({ ...prev, exportPreview: output, statusLine: 'Export generated' }));
+            appendLog(`[export] Generated ${state.exportFormat} (${output.anchorCount} anchors)`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendLog(`[error] Export generation failed: ${message}`);
+            setState((prev) => ({ ...prev, statusLine: 'Export generation failed' }));
+        }
+    }, [appendLog, service, state.boot, state.client, state.exportFormat]);
+    const bridgeStart = (0, react_1.useCallback)(() => {
+        service.startLocalBridgeDetached();
+        appendLog('[bridge] Started local bridge process (detached)');
+        setState((prev) => ({ ...prev, statusLine: 'Bridge start triggered (detached)' }));
+    }, [appendLog, service]);
+    const bridgeStop = (0, react_1.useCallback)(async () => {
+        await service.stopLocalBridge(state.localBridge?.port);
+        appendLog('[bridge] Stop signal sent');
+        setState((prev) => ({ ...prev, statusLine: 'Bridge stop signal sent' }));
+    }, [appendLog, service, state.localBridge?.port]);
+    return {
+        state,
+        refresh,
+        setScreen,
+        toggleHelp,
+        setSearchQuery,
+        setCommandMode,
+        setExportFormat,
+        previewExport,
+        generateExport,
+        bridgeStart,
+        bridgeStop,
+        appendLog,
+    };
+}

package/dist/tui/types.d.ts

@@ -0,0 +1,77 @@
+import type { OrganizationPlan, WorkflowPhase } from './shared-enums';
+export type TuiScreenId = 'home' | 'specs' | 'export' | 'decisions' | 'bridge' | 'active-runs' | 'phase-gates' | 'skills-marketplace' | 'org-governance';
+export type TuiRole = 'owner' | 'admin' | 'member' | 'viewer';
+export type ActionState = 'enabled' | 'disabled' | 'locked';
+export interface CapabilityContext {
+    plan: OrganizationPlan;
+    role: TuiRole;
+    workflowPhase: WorkflowPhase | null;
+    permissions: string[];
+}
+export interface NavItemPolicy {
+    id: TuiScreenId;
+    label: string;
+    description: string;
+    requiredPlan: OrganizationPlan;
+    state: ActionState;
+    reason?: string;
+}
+export interface TuiBootContext {
+    apiUrl: string;
+    organizationId: string;
+    organizationName: string;
+    role: TuiRole;
+    plan: OrganizationPlan;
+    projectId: string;
+    projectName: string;
+    permissions: string[];
+}
+export interface SpecListItem {
+    id: string;
+    title: string;
+    status: string;
+    version: string;
+    updatedAt?: string;
+    type?: string;
+}
+export interface DecisionListItem {
+    id: string;
+    title: string;
+    status: string;
+    decisionType: string;
+    specAnchor?: string | null;
+    createdAt?: string;
+}
+export interface WorkflowSummary {
+    currentPhase: WorkflowPhase | null;
+    blockedCount: number;
+    hasVerificationEvidence: boolean;
+    hasPlanningArtifacts: boolean;
+}
+export interface BridgeSummary {
+    featureEnabled: boolean;
+    devices: Array<{
+        id: string;
+        name: string;
+        status: string;
+        isDefault: boolean;
+        lastSeenAt?: string | null;
+    }>;
+    connectedDevices: number;
+    authFailures: number;
+}
+export interface LocalBridgeSummary {
+    paired: boolean;
+    deviceId?: string;
+    deviceName?: string;
+    port: number;
+    running: boolean;
+    uptimeSec?: number;
+}
+export type ExportFormat = 'claude-md' | 'cursorrules';
+export interface ExportPreview {
+    content: string;
+    anchorCount: number;
+    specVersion?: string;
+    warnings?: string[];
+}

package/dist/tui/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tui/use-session-store-63YUGUFA.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-OXXZ3O5L.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-ACO2SMJC.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-GTFTFDY4.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-BVFDAWOB.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-X2XP5ACW.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-DJIZ3FQZ.mjs

@@ -0,0 +1,9 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-V4SNDRUS.mjs";
+import "./chunk-JKFOY4IF.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-EAIQA4UG.mjs

@@ -0,0 +1,9 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-VXVHNZST.mjs";
+import "./chunk-BZKKMGFB.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-EFBAXC3G.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-ZM3EI5IA.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-FJOR4KTG.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-BUJQVTY5.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-IJE5KVOC.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-DJYOBCNM.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-KGAFXCKI.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-4WEASLXY.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-KS4DPNDY.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-755CADEG.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};

package/dist/tui/use-session-store-MMHJENNL.mjs

@@ -0,0 +1,8 @@
+import {
+  buildOnboardingState,
+  useSessionStore
+} from "./chunk-IMEBD2KA.mjs";
+export {
+  buildOnboardingState,
+  useSessionStore
+};