@wenathlan/saddle 2.0.150 → 2.0.152

package/dist/family.d.ts

@@ -0,0 +1,16 @@
+/** the sibling deploy units beside saddle, rail order (saddle itself is not
+ * listed — the row links OUT, never back). */
+export declare const FAMILY_SLUGS: readonly string[];
+/** one family member: the slug, the display accent and the dot ink that rides
+ * on the accent (the spec's accent-ink column). */
+export type FamilyMember = {
+    slug: string;
+    accent: string;
+    dotInk: string;
+};
+/** the spec §12 accent table for the eight siblings (saddle's own ember
+ * #e86f2d lives in the theme tokens, never in this row). */
+export declare const FAMILY_ACCENTS: Readonly<Record<string, FamilyMember>>;
+/** the family row in rail order, each with its accent; unknown slugs are
+ * skipped (the row only ever links real deploy units). */
+export declare function familyrow(): readonly FamilyMember[];

package/dist/family.js

@@ -0,0 +1,42 @@
+// # family — the family table of saddle (root layer, beside familyurl.ts).
+// The deploy units of the wenathlan family with the one accent each carries
+// (the spec §12 table, mirrored from the devthink familyidentity wave and
+// from the cadria contract) and the slugs in rail order. Pure data, no
+// imports: the chrome (the shell rail foot), the landing footer and the
+// node:test suite all consume this one table, so the family row can never
+// drift between surfaces.
+/** the sibling deploy units beside saddle, rail order (saddle itself is not
+ * listed — the row links OUT, never back). */
+export const FAMILY_SLUGS = [
+    'argan',
+    'cadria',
+    'debonair',
+    'forge',
+    'foundry',
+    'getry',
+    'stealthhead',
+    'vault',
+];
+/** the spec §12 accent table for the eight siblings (saddle's own ember
+ * #e86f2d lives in the theme tokens, never in this row). */
+export const FAMILY_ACCENTS = {
+    argan: { slug: 'argan', accent: '#34d8a8', dotInk: '#04231a' },
+    cadria: { slug: 'cadria', accent: '#f472b6', dotInk: '#2a0715' },
+    debonair: { slug: 'debonair', accent: '#d9962e', dotInk: '#241703' },
+    forge: { slug: 'forge', accent: '#a2cb3a', dotInk: '#161d03' },
+    foundry: { slug: 'foundry', accent: '#2fb8b5', dotInk: '#03211f' },
+    getry: { slug: 'getry', accent: '#8b5cf6', dotInk: '#120533' },
+    stealthhead: { slug: 'stealthhead', accent: '#e8563f', dotInk: '#2c0703' },
+    vault: { slug: 'vault', accent: '#a3d7e6', dotInk: '#072330' },
+};
+/** the family row in rail order, each with its accent; unknown slugs are
+ * skipped (the row only ever links real deploy units). */
+export function familyrow() {
+    const row = [];
+    for (const slug of FAMILY_SLUGS) {
+        const member = FAMILY_ACCENTS[slug];
+        if (member)
+            row.push(member);
+    }
+    return row;
+}

package/dist/familyurl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * familyurl.ts — the url of a family application beside this one (root
+ * layer).
+ *
+ * the family deploys as sibling folders on one host: saddle lives at
+ * /saddle/, the other deploy units at /<slug>/, and every cross-application
+ * link must survive any mount point (project pages, self-hosted domains,
+ * bare local preview servers) without trusting a build constant or reading
+ * the live location. the helper therefore builds a RELATIVE url — one level
+ * up from the current deploy unit, then into the sibling folder — so the
+ * chrome of the window resolves the family from wherever the app is
+ * mounted. pure and multi-mode: the same call runs in the browser and in
+ * node (the unit tests), with zero storage.
+ */
+/** resolves the url of a family deploy unit that shares this host.
+ *
+ * @param slug the deploy unit segment (the app folder name); decorative
+ *   slashes are stripped.
+ * @returns the relative path of the family application, slash-terminated.
+ */
+export declare function familyurl(slug: string): string;

package/dist/familyurl.js

@@ -0,0 +1,24 @@
+/**
+ * familyurl.ts — the url of a family application beside this one (root
+ * layer).
+ *
+ * the family deploys as sibling folders on one host: saddle lives at
+ * /saddle/, the other deploy units at /<slug>/, and every cross-application
+ * link must survive any mount point (project pages, self-hosted domains,
+ * bare local preview servers) without trusting a build constant or reading
+ * the live location. the helper therefore builds a RELATIVE url — one level
+ * up from the current deploy unit, then into the sibling folder — so the
+ * chrome of the window resolves the family from wherever the app is
+ * mounted. pure and multi-mode: the same call runs in the browser and in
+ * node (the unit tests), with zero storage.
+ */
+/** resolves the url of a family deploy unit that shares this host.
+ *
+ * @param slug the deploy unit segment (the app folder name); decorative
+ *   slashes are stripped.
+ * @returns the relative path of the family application, slash-terminated.
+ */
+export function familyurl(slug) {
+    // biome-ignore lint/style/useTemplate: the family contract body stays verbatim — every app of the family copies this exact line
+    return "../" + slug.replace(/^\/+|\/+$/g, "") + "/";
+}

package/dist/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * format.ts — the formatting gate used by the check pipeline.
+ *
+ * This file is the v2.0.0 grand-merge consolidation of the former nested
+ * folders of the repository (format) 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.
+ */
+/** Finds domain files that do not follow the skill formatting contract. */
+export declare function formatissues(root?: string): Promise<any[]>;
+/** Runs the check as a CLI and throws a short diagnostic on failure. */
+export declare function runformatcheck(): Promise<{
+    ok: boolean;
+    checked: number;
+}>;

package/dist/format.js

@@ -0,0 +1,59 @@
+/**
+ * format.ts — the formatting gate used by the check pipeline.
+ *
+ * This file is the v2.0.0 grand-merge consolidation of the former nested
+ * folders of the repository (format) 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.
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+/* ════════════════════════════════════════════════════════════════════ */
+/* Section 1: format/check.ts — format check validates the public root based JavaScript layout before release. */
+/* ════════════════════════════════════════════════════════════════════ */
+/**
+ * format check validates the public root based JavaScript layout before release.
+ */
+/* the grand-merge layout: the public logic surface is the flat set of root
+   domain TypeScript files; the formatting contract checks each of them. */
+const domains = ["index", "foundation", "isolation", "virtual", "execution", "browser", "communication", "integration", "automation", "intelligence", "distribution", "modes", "cli", "server", "format", "alternatives", "compute", "media", "orchestrator", "performance", "quantum", "render", "scheduler", "security", "tiers", "virtualcpu", "virtualgpu", "virtualization", "virtualmemory"];
+/** Finds domain files that do not follow the skill formatting contract. */
+export async function formatissues(root = process.cwd()) {
+    const issues = [];
+    for (const domain of domains) {
+        const file = join(root, `${domain}.ts`);
+        let source;
+        try {
+            source = await readFile(file, "utf8");
+        }
+        catch {
+            issues.push(`${domain}.ts: missing domain file`);
+            continue;
+        }
+        if (/[A-Z_-]/.test(domain))
+            issues.push(`${domain}.ts: invalid path format`);
+        if (!source.includes("/**"))
+            issues.push(`${domain}.ts: missing jsdoc`);
+    }
+    return issues;
+}
+/** Runs the check as a CLI and throws a short diagnostic on failure. */
+export async function runformatcheck() { const issues = await formatissues(); if (issues.length)
+    throw new Error(issues.join("\n")); return { ok: true, checked: domains.length }; }
+async function javascriptfiles(directory) { let entries; try {
+    entries = await readdir(directory, { withFileTypes: true });
+}
+catch {
+    return [];
+} const files = []; for (const entry of entries) {
+    const file = join(directory, entry.name);
+    if (entry.isDirectory())
+        files.push(...await javascriptfiles(file));
+    else if (entry.name.endsWith(".js"))
+        files.push(file);
+} return files; }
+if (import.meta.url === `file://${process.argv[1]}`)
+    runformatcheck().then((result) => console.log(JSON.stringify(result))).catch((error) => { console.error(error.message); process.exitCode = 1; });

package/dist/foundation.d.ts

@@ -0,0 +1,172 @@
+/**
+ * foundation.ts — foundation errors, events, identifiers, hashing and serializable domain nouns.
+ *
+ * This file is the v2.0.0 grand-merge consolidation of the former nested
+ * folders of the repository (core) 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.
+ */
+/**
+ * typed engine errors keep recovery decisions explicit.
+ */
+export declare const errorcodes: Readonly<{
+    invalidinput: "INVALID_INPUT";
+    artifactnotfound: "ARTIFACT_NOT_FOUND";
+    storagefailure: "STORAGE_FAILURE";
+    runnerunavailable: "RUNNER_UNAVAILABLE";
+    jobfailed: "JOB_FAILED";
+    sessioninvalid: "SESSION_INVALID";
+}>;
+export declare function saddleerror(message: any, options?: {}): Error;
+export declare function validationerror(message: any, details?: {}): Error;
+export declare function artifactnotfound(key: any): Error;
+export declare function runnerunavailable(jobid: any): Error;
+export declare function aserror(error: any, jobid: any): any;
+/** Operational error presets keep status, recovery and retry decisions
+ * explicit for the engine's outbound lanes (registry pulls, runner
+ * handshakes, package fetches); the presets answer the sandbox engine
+ * only — the scrape lanes that once consumed them left the package. */
+export declare const errorcatalog: Readonly<{
+    timeout: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    connectionrefused: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    dns: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    ratelimited: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    forbidden: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    notfound: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    parse: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    session: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+    config: {
+        code: string;
+        statuscode: number;
+        retryable: boolean;
+        recovery: string;
+    };
+}>;
+/** Creates a stable operational error with recovery metadata. */
+export declare function operationerror(kind: any, message: any, options?: {}): Error;
+/** Converts unknown failures into the stable operational taxonomy. */
+export declare function classifyerror(error: any): any;
+/**
+ * append only events are the small protocol shared by adapters.
+ */
+export declare const eventtypes: readonly string[];
+export declare function eventbus(): {
+    emit(event: any): void;
+    all(): any[];
+};
+/**
+ * injectable time and id factories make every engine path reproducible.
+ */
+export declare function systemclock(): {
+    now: () => number;
+};
+export declare function idfactory(randomuuid?: any): {
+    next(prefix: any): string;
+};
+/** Returns a SHA-256 hexadecimal digest for bytes or text. */
+export declare function sha256(value: any): string;
+/** Returns an HMAC-SHA-256 hexadecimal digest for bytes or text. */
+export declare function hmacsha256(value: any, secret: any): string;
+/** Compares hexadecimal values without early exit based on content. */
+export declare function constanttimeequal(left: any, right: any): boolean;
+/**
+ * artifacts are serializable manifests with content checksums.
+ */
+export declare function artifactmanifest(input: any): {
+    key: any;
+    sizebytes: any;
+    sha256: any;
+    contenttype: any;
+    createdat: any;
+    metadata: any;
+};
+/**
+ * job creation is kept small and side effect free.
+ */
+export declare const jobstatuses: readonly string[];
+export declare function createjob(spec: any, ids: any, clock: any): {
+    id: any;
+    name: any;
+    input: any;
+    priority: any;
+    outputkey: any;
+    metadata: any;
+    status: string;
+    createdat: any;
+};
+/**
+ * providers declare capacity while scheduling remains a runtime decision.
+ */
+export declare const runnerstatuses: readonly string[];
+export declare function runnercontext(job: any, workingset: any, signal: any): {
+    job: any;
+    workingset: any;
+    signal: any;
+};
+/**
+ * runtime records describe temporary process space without claiming physical vram.
+ */
+export declare function workingset(jobid: any, location: any, resultpath: any, createdat?: number): {
+    jobid: any;
+    location: any;
+    resultpath: any;
+    createdat: number;
+};
+export declare function syncresult(bytes: any, location: any): {
+    bytes: any;
+    location: any;
+};
+export declare function validatesession(value: any): {
+    version: number;
+    id: any;
+    agentname: any;
+    originurl: any;
+    seed: any;
+    status: any;
+    startedat: any;
+    finishedat: any;
+    events: any;
+};