@wenathlan/saddle 2.0.154 → 2.0.155

package/dist/modes.d.ts

@@ -1,358 +0,0 @@
-/**
- * modes.ts — target mode resolution and host-neutral deployment contracts.
- *
- * This file is the v2.0.0 grand-merge consolidation of the former nested
- * folders of the repository (modes) into the single
- * root-level domain file of the saddle family standard: one optimized
- * TypeScript file per correlated domain, ordinal sections, JSDoc on every
- * block, intra-domain imports dissolved, cross-domain imports rewritten to
- * ./<domain>.js. Every capability of every source file is preserved here;
- * the pure re-export barrels (none in this domain) folded their surface into this file directly.
- */
-export declare function modeprofile(options?: {}): {
-    [k: string]: {
-        name: string;
-        enabled: boolean;
-        paired: boolean;
-    };
-};
-export declare function librarymode(factory: any): {
-    name: string;
-    start: any;
-    stop: () => Promise<any>;
-};
-export declare function climode(run: any): {
-    name: string;
-    run: any;
-};
-export declare function binarymode(run: any): {
-    name: string;
-    run: any;
-};
-export declare function browsermode(adapter: any): {
-    name: string;
-    adapter: any;
-};
-export declare function headlessmode(adapter: any): {
-    name: string;
-    adapter: any;
-};
-export declare function computemode(adapter: any): {
-    name: string;
-    adapter: any;
-};
-/**
- * mode matrix keeps supported execution choices in one grouped contract.
- */
-export declare const modeaxes: Readonly<{
-    execution: string[];
-    runtime: string[];
-    memory: string[];
-    file: string[];
-    dependency: string[];
-    visibility: string[];
-    pair: string[];
-}>;
-export declare const operationmodes: readonly string[];
-/** Returns true when the matrix contains the requested axis value. */
-export declare function validatemode(axis: any, value: any): boolean;
-/** Returns a serializable snapshot for documentation and diagnostics. */
-export declare function modecatalog(): {
-    axes: {
-        [k: string]: string[];
-    };
-    operationmodes: string[];
-};
-/**
- * mode resolver selects open defaults while preserving every caller choice.
- */
-/** Resolves an execution profile without starting a process or opening a socket. */
-export declare function resolvemode(options?: {}): {
-    execution: any;
-    runtime: any;
-    memory: any;
-    file: any;
-    dependency: any;
-    visibility: any;
-    pair: any;
-    capabilities: {
-        library: boolean;
-        browser: boolean;
-        cli: boolean;
-        physicalmemory: boolean;
-        vectorizedmemory: boolean;
-        externalmemory: boolean;
-        externalfile: boolean;
-        externaldependency: boolean;
-        visible: boolean;
-    };
-};
-/** Returns stable capabilities for adapters and diagnostics. */
-export declare function modecapabilities(profile: any): {
-    library: boolean;
-    browser: boolean;
-    cli: boolean;
-    physicalmemory: boolean;
-    vectorizedmemory: boolean;
-    externalmemory: boolean;
-    externalfile: boolean;
-    externaldependency: boolean;
-    visible: boolean;
-};
-/** Returns a stable cross-runtime capability report without starting infrastructure. */
-export declare function capabilityreport(options?: {}): {
-    version: number;
-    axes: {
-        [k: string]: string[];
-    };
-    overrides: {
-        runtime: any;
-        memory: any;
-        file: any;
-        dependency: any;
-        visibility: any;
-        pair: any;
-    };
-    profiles: {
-        mode: string;
-        capabilities: {
-            library: boolean;
-            browser: boolean;
-            cli: boolean;
-            physicalmemory: boolean;
-            vectorizedmemory: boolean;
-            externalmemory: boolean;
-            externalfile: boolean;
-            externaldependency: boolean;
-            visible: boolean;
-        };
-        profile: {
-            execution: any;
-            runtime: any;
-            memory: any;
-            file: any;
-            dependency: any;
-            visibility: any;
-            pair: any;
-            capabilities: {
-                library: boolean;
-                browser: boolean;
-                cli: boolean;
-                physicalmemory: boolean;
-                vectorizedmemory: boolean;
-                externalmemory: boolean;
-                externalfile: boolean;
-                externaldependency: boolean;
-                visible: boolean;
-            };
-        };
-    }[];
-    infrastructure: {
-        host: string;
-        port: string;
-        credentials: string;
-        provider: string;
-    };
-};
-/** Applies one profile to a caller supplied operation. */
-export declare function withmode(options: any, operation: any): Promise<any>;
-/**
- * deploy surface exposes artifact planning without performing provider mutations.
- */
-export { publishplan, registrymanifest } from "./distribution.js";
-export { surfacemanifest, surfacebundle } from "./automation.js";
-/**
- * target profiles keep platform packaging open and describe capability boundaries.
- */
-export declare const targetprofiles: Readonly<{
-    application: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    computer: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    desktopapp: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    mobileapp: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    android: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    ios: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    cli: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    binary: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    browser: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    extension: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    internet: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    web: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    libreoffice: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    mcp: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    vsix: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-    container: {
-        runtime: string;
-        entry: string;
-        capabilities: string[];
-        formats: string[];
-    };
-}>;
-/** Creates a surface target with caller supplied entry and capabilities. */
-export declare function targetmanifest(target: any, options?: {}): {
-    target: any;
-    runtime: any;
-    entry: any;
-    formats: any;
-    capabilities: any;
-    permissions: any;
-    metadata: any;
-};
-/** Returns all supported target profiles for documentation and tooling. */
-export declare function targetcatalog(): {
-    [k: string]: {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    } | {
-        runtime: string;
-        entry: string;
-        formats: string[];
-        capabilities: string[];
-    };
-};

package/dist/modes.js

@@ -1,133 +0,0 @@
-/**
- * modes.ts — target mode resolution and host-neutral deployment contracts.
- *
- * This file is the v2.0.0 grand-merge consolidation of the former nested
- * folders of the repository (modes) into the single
- * root-level domain file of the saddle family standard: one optimized
- * TypeScript file per correlated domain, ordinal sections, JSDoc on every
- * block, intra-domain imports dissolved, cross-domain imports rewritten to
- * ./<domain>.js. Every capability of every source file is preserved here;
- * the pure re-export barrels (none in this domain) folded their surface into this file directly.
- */
-/* ════════════════════════════════════════════════════════════════════ */
-/* Section 1: modes/modes.ts — mode profiles describe paired operation surfaces without changing engine contracts. */
-/* ════════════════════════════════════════════════════════════════════ */
-/**
- * mode profiles describe paired operation surfaces without changing engine contracts.
- */
-const names = ["computer", "library", "application", "browser", "desktop", "mobile", "extension", "cli", "binary", "internet", "physicalfile", "vectorfile", "visible", "headless"];
-export function modeprofile(options = {}) {
-    const enabled = new Set(options.enabled ?? ["library", "cli", "binary"]);
-    return Object.fromEntries(names.map((name) => [name, { name, enabled: enabled.has(name), paired: Boolean(options.paired?.includes(name)) }]));
-}
-export function librarymode(factory) { return { name: "library", start: factory, stop: async () => undefined }; }
-export function climode(run) { return { name: "cli", run }; }
-export function binarymode(run) { return { name: "binary", run }; }
-export function browsermode(adapter) { return { name: "browser", adapter }; }
-export function headlessmode(adapter) { return { name: "headless", adapter }; }
-export function computemode(adapter) { return { name: "computer", adapter }; }
-/* ════════════════════════════════════════════════════════════════════ */
-/* Section 2: modes/matrix.ts — mode matrix keeps supported execution choices in one grouped contract. */
-/* ════════════════════════════════════════════════════════════════════ */
-/**
- * mode matrix keeps supported execution choices in one grouped contract.
- */
-export const modeaxes = Object.freeze({
-    execution: ["library", "application", "browser", "desktopapp", "mobileapp", "extension", "cli", "binary", "computer", "internet"],
-    runtime: ["node", "browser", "deno", "bun", "worker", "unknown"],
-    memory: ["internal", "external", "physical", "vectorized", "library"],
-    file: ["internal", "external", "physical", "vector"],
-    dependency: ["internal", "external", "dev"],
-    visibility: ["visible", "headless"],
-    pair: ["without", "with"]
-});
-export const operationmodes = Object.freeze(modeaxes.execution.flatMap((execution) => modeaxes.pair.map((pair) => `${execution}${pair}`)));
-/** Returns true when the matrix contains the requested axis value. */
-export function validatemode(axis, value) { return Boolean(modeaxes[axis]?.includes(value)); }
-/** Returns a serializable snapshot for documentation and diagnostics. */
-export function modecatalog() { return { axes: Object.fromEntries(Object.entries(modeaxes).map(([key, values]) => [key, [...values]])), operationmodes: [...operationmodes] }; }
-/* ════════════════════════════════════════════════════════════════════ */
-/* Section 3: modes/resolve.ts — mode resolver selects open defaults while preserving every caller choice. */
-/* ════════════════════════════════════════════════════════════════════ */
-/**
- * mode resolver selects open defaults while preserving every caller choice.
- */
-/** Resolves an execution profile without starting a process or opening a socket. */
-export function resolvemode(options = {}) {
-    const profile = {
-        execution: options.execution ?? "library",
-        runtime: options.runtime ?? "unknown",
-        memory: options.memory ?? "internal",
-        file: options.file ?? "internal",
-        dependency: options.dependency ?? "internal",
-        visibility: options.visibility ?? "headless",
-        pair: options.pair ?? "without"
-    };
-    for (const [axis, value] of Object.entries(profile))
-        if (!validatemode(axis, value))
-            throw new TypeError(`unsupported mode ${axis}:${value}`);
-    return { ...profile, capabilities: modecapabilities(profile) };
-}
-/** Returns stable capabilities for adapters and diagnostics. */
-export function modecapabilities(profile) {
-    return {
-        library: profile.execution === "library" || profile.execution === "application",
-        browser: profile.execution === "browser" || profile.execution === "extension" || profile.runtime === "browser" || profile.runtime === "worker",
-        cli: profile.execution === "cli" || profile.execution === "binary",
-        physicalmemory: profile.memory === "physical",
-        vectorizedmemory: profile.memory === "vectorized",
-        externalmemory: profile.memory === "external",
-        externalfile: profile.file === "external",
-        externaldependency: profile.dependency === "external",
-        visible: profile.visibility === "visible"
-    };
-}
-/** Returns a stable cross-runtime capability report without starting infrastructure. */
-export function capabilityreport(options = {}) {
-    const overrides = { runtime: options.runtime ?? "unknown", memory: options.memory ?? "internal", file: options.file ?? "internal", dependency: options.dependency ?? "internal", visibility: options.visibility ?? "headless", pair: options.pair ?? "without" };
-    const profiles = modeaxes.execution.map((execution) => {
-        const profile = resolvemode({ ...overrides, execution });
-        return { mode: execution, capabilities: profile.capabilities, profile };
-    });
-    return { version: 1, axes: Object.fromEntries(Object.entries(modeaxes).map(([key, values]) => [key, [...values]])), overrides, profiles, infrastructure: { host: "caller-owned", port: "caller-owned", credentials: "caller-owned", provider: "caller-owned" } };
-}
-/** Applies one profile to a caller supplied operation. */
-export async function withmode(options, operation) { if (typeof operation !== "function")
-    throw new TypeError("mode operation is required"); return operation(resolvemode(options)); }
-/* ════════════════════════════════════════════════════════════════════ */
-/* Section 4: modes/deploy.ts — deploy surface exposes artifact planning without performing provider mutations. */
-/* ════════════════════════════════════════════════════════════════════ */
-/**
- * deploy surface exposes artifact planning without performing provider mutations.
- */
-export { publishplan, registrymanifest } from "./distribution.js";
-export { surfacemanifest, surfacebundle } from "./automation.js";
-/* ════════════════════════════════════════════════════════════════════ */
-/* Section 5: modes/targets.ts — target profiles keep platform packaging open and describe capability boundaries. */
-/* ════════════════════════════════════════════════════════════════════ */
-/**
- * target profiles keep platform packaging open and describe capability boundaries.
- */
-export const targetprofiles = Object.freeze({
-    application: { runtime: "caller", entry: "dist/index.js", capabilities: ["memory", "storage", "network"], formats: ["zip", "tarball"] },
-    computer: { runtime: "node", entry: "dist/index.js", capabilities: ["memory", "storage", "runner"], formats: ["node", "bun", "deno", "singlefile"] },
-    desktopapp: { runtime: "tauri", entry: "desktop/src-tauri", capabilities: ["memory", "file", "visible"], formats: ["appimage", "deb", "rpm", "snap", "flatpak", "dmg", "pkg", "exe", "msi", "msix"] },
-    mobileapp: { runtime: "capacitor", entry: "index.html", capabilities: ["memory", "network", "visible"], formats: ["apk", "aab", "ipa"] },
-    android: { runtime: "capacitor", entry: "android", capabilities: ["memory", "network", "visible"], formats: ["apk", "aab"] },
-    ios: { runtime: "capacitor", entry: "ios", capabilities: ["memory", "network", "visible"], formats: ["ipa"] },
-    cli: { runtime: "node", entry: "dist/cli/main.js", capabilities: ["memory", "storage", "network"], formats: ["node", "bun", "deno", "singlefile", "exe", "deb", "rpm"] },
-    binary: { runtime: "caller", entry: "dist/cli/main.js", capabilities: ["memory", "storage", "runner"], formats: ["sea", "singlefile", "wasm"] },
-    browser: { runtime: "tauri", entry: "desktop/src-tauri", capabilities: ["memory", "network", "visible"], formats: ["html", "pwa", "wasm", "appimage", "deb", "rpm", "dmg", "exe", "msi"] },
-    extension: { runtime: "browser", entry: "dist/extension/index.js", capabilities: ["browser", "network", "visible"], formats: ["crx", "xpi", "safariextz"] },
-    internet: { runtime: "caller", entry: "dist/index.js", capabilities: ["network", "webhook", "api"], formats: ["http", "websocket", "grpc", "rest"] },
-    web: { runtime: "browser", entry: "index.html", capabilities: ["network", "visible"], formats: ["html", "pwa", "ssg", "ssr", "wasm"] },
-    libreoffice: { runtime: "caller", entry: "dist/index.js", capabilities: ["file", "network"], formats: ["oxt", "zip"] },
-    mcp: { runtime: "caller", entry: "dist/adapters/mcpserver.js", capabilities: ["network", "api"], formats: ["stdio", "jsonrpc"] },
-    vsix: { runtime: "caller", entry: "dist/index.js", capabilities: ["network", "visible"], formats: ["vsix"] },
-    container: { runtime: "node", entry: "dist/index.js", capabilities: ["memory", "storage", "network"], formats: ["oci", "docker"] }
-});
-/** Creates a surface target with caller supplied entry and capabilities. */
-export function targetmanifest(target, options = {}) { const profile = targetprofiles[target]; if (!profile)
-    throw new TypeError(`unsupported target: ${target}`); return { target, runtime: options.runtime ?? profile.runtime, entry: options.entry ?? profile.entry, formats: options.formats ?? [...profile.formats], capabilities: options.capabilities ?? [...profile.capabilities], permissions: options.permissions ?? [], metadata: options.metadata ?? {} }; }
-/** Returns all supported target profiles for documentation and tooling. */
-export function targetcatalog() { return Object.fromEntries(Object.entries(targetprofiles).map(([key, value]) => [key, { ...value, capabilities: [...value.capabilities] }])); }

package/dist/onboardingstate.d.ts

@@ -1,79 +0,0 @@
-/**
- * onboardingstate.ts — the ONE writer of the visitor's first-run flags, the
- * state of the entry-flow contract (intro → onboarding → the platform). The
- * state is { introseen, onboardingseen } and it is catalogued, not just
- * browser: the accessor consults the platform database over GET
- * /api/v1/onboarding and writes it over POST /api/v1/onboarding, both HTTPS
- * only — the base url arrives through VITE_ONBOARDING_URL and every
- * candidate host is validated first (localhost, loopback, private,
- * link-local, CGNAT and the reserved documentation ranges are refused, so
- * the flags never ride a dev or internal endpoint; mapped IPv6 literals are
- * normalized back to their embedded IPv4 before the public check). The
- * localStorage key saddle.onboarding.seen is purely the offline cache of
- * the database (the DB is the source of truth; the cache avoids replaying
- * the flow offline) and module memory covers client-side re-navigation.
- * Reads reconcile with a seen-wins merge — a stage seen anywhere stays
- * seen, the flow is never forced twice. The page anchors never touch the
- * flags directly: the intro marks introseen, the onboarding marks
- * onboardingseen, the home entry gate only reads.
- */
-/** the visitor state the entry flow consults (the two gates of the app). */
-export type VisitorOnboarding = {
-    /** the animated intro was seen — the splash never replays */
-    introseen: boolean;
-    /** the first-run onboarding was seen (finish or skip) — never forced again */
-    onboardingseen: boolean;
-};
-/** the stages one call can mark seen. */
-export type OnboardingStage = 'intro' | 'onboarding';
-/**
- * Validates a platform base url: HTTPS only, and the host must be public —
- * localhost, loopback, private, link-local, CGNAT, benchmarking,
- * unique-local and the reserved documentation ranges are refused; a mapped
- * IPv6 literal is normalized to its embedded IPv4 first; any other IPv6
- * literal is refused (the gateway rides a name).
- *
- * @param base the configured base url candidate.
- * @returns true when the base may be consulted.
- */
-export declare function hostallowed(base: string): boolean;
-/**
- * Answers the flags after one stage was marked seen (pure: the writer and
- * the tests share this merge — seen-wins, a stage never unsees).
- *
- * @param state the flags before the write.
- * @param stage the stage being marked seen.
- * @returns the flags after the write.
- */
-export declare function mergeStage(state: VisitorOnboarding, stage: OnboardingStage): VisitorOnboarding;
-/**
- * Synchronous read of the known state: module memory first, then the
- * localStorage cache. The entry gate uses this for the flash-free fast
- * path; null means the state is still unknown and the caller must await
- * loadOnboardingState.
- *
- * @returns the known flags, or null when nothing is known yet.
- */
-export declare function readOnboardingState(): VisitorOnboarding | null;
-/**
- * Full resolve of the flags: memory/cache first, then the platform database
- * over GET /api/v1/onboarding — reconciled with the seen-wins merge so a
- * stage seen anywhere stays seen. The session answer is memoized;
- * re-navigation never refetches.
- *
- * @returns the resolved visitor onboarding flags.
- */
-export declare function loadOnboardingState(): Promise<VisitorOnboarding>;
-/**
- * Marks the intro stage seen and persists it everywhere: module memory, the
- * localStorage cache and — when a platform base is configured — the
- * database over POST /api/v1/onboarding. The ONLY writer of the intro flag.
- */
-export declare function markIntroSeen(): void;
-/**
- * Marks the onboarding stage seen (finish or skip — both imply the intro)
- * and persists it everywhere. The ONLY writer of the onboarding flag.
- */
-export declare function markOnboardingSeen(): void;
-/** Test seam: clears the module memory (the cache and the platform are untouched). */
-export declare function resetOnboardingMemory(): void;