@wenathlan/saddle 2.0.151 → 2.0.152

package/dist/drizzle.config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * drizzle.config.ts — saddle v7 drizzle kit configuration (worklog task
+ * v7-BACK).
+ *
+ * a plain typed object with the three fields drizzle-kit expects for a
+ * raw-sql sqlite project: the sqlite dialect, the schema file (the same
+ * web/init.sql shared with node:sqlite and prisma) and the
+ * output directory for generated artifacts. the file intentionally
+ * imports nothing so typecheck and boot never depend on drizzle-kit
+ * being installed; drizzle-kit reads the default export as-is.
+ */
+/** the drizzle-kit configuration shape for dialect sqlite. */
+export interface drizzleconfig {
+    dialect: 'sqlite';
+    schema: string;
+    out: string;
+}
+/** the configuration consumed by `drizzle-kit generate` and friends. */
+declare const config: drizzleconfig;
+export default config;

package/dist/drizzle.config.js

@@ -0,0 +1,18 @@
+/**
+ * drizzle.config.ts — saddle v7 drizzle kit configuration (worklog task
+ * v7-BACK).
+ *
+ * a plain typed object with the three fields drizzle-kit expects for a
+ * raw-sql sqlite project: the sqlite dialect, the schema file (the same
+ * web/init.sql shared with node:sqlite and prisma) and the
+ * output directory for generated artifacts. the file intentionally
+ * imports nothing so typecheck and boot never depend on drizzle-kit
+ * being installed; drizzle-kit reads the default export as-is.
+ */
+/** the configuration consumed by `drizzle-kit generate` and friends. */
+const config = {
+    dialect: 'sqlite',
+    schema: './init.sql',
+    out: './drizzleout',
+};
+export default config;

package/dist/edgelandes.d.ts

@@ -0,0 +1,70 @@
+/** one lane artifact: the bytes the lane produced and the mime they answer. */
+export interface EdgeLaneArtifact {
+    /** the mime type of the produced bytes. */
+    mime: string;
+    /** the produced bytes. */
+    bytes: Uint8Array;
+}
+/** the output one lane executor answers: the captured streams and the
+ * optional artifact the run committed. */
+export interface EdgeLaneOutput {
+    /** the captured stdout of the lane run. */
+    stdout: string;
+    /** the captured stderr of the lane run when the lane produced any. */
+    stderr?: string;
+    /** the lane specific artifact when the run produced one. */
+    artifact?: EdgeLaneArtifact;
+}
+/** one modality lane executor: (code, inputs, deadline) riding the lane.
+ * The code field is the program for the runner and language lanes, the
+ * base64 module bytes for the wasm lane and the payload bytes for the
+ * vfs lane; the inputs ride the sandbox global (in process lanes) or the
+ * inputs.json file the host lanes write beside the program; the deadline
+ * is the hard budget in milliseconds. */
+export type EdgeLaneExecutor = (code: string, inputs: unknown, deadline: number) => Promise<EdgeLaneOutput>;
+/** the coded failure one lane throws when it cannot run honestly. */
+export interface EdgeLaneError extends Error {
+    /** the lane error name (always "edgelaneerror"). */
+    name: "edgelaneerror";
+    /** the machine readable lane error code. */
+    code: string;
+    /** the captured stderr of the failed run when the lane produced any. */
+    stderr?: string;
+}
+/** creates one coded lane error; the edge dispatcher reads the code and
+ * never invents a success a lane did not answer. */
+export declare function edgelaneerror(code: string, message: string, details?: {
+    stderr?: string;
+}): EdgeLaneError;
+/** probes one host binary on PATH synchronously (command -v through
+ * bash): the honest present check of the lane table. */
+export declare function probehostbinary(binary: string): boolean;
+/** probes the docker lane surface: the binary on PATH or the daemon socket. */
+export declare function probedocker(): boolean;
+/** probes the engine's own webassembly (the in process wasm lane). */
+export declare function probewasm(): boolean;
+/** probes the node:vm surface (the in process runner lane). */
+export declare function probenodevm(): boolean;
+/** probes one engine module through the node resolver (createRequire):
+ * the honest check for @babel/core and webpack without loading them. */
+export declare function probemodule(specifier: string): boolean;
+/** probes the engine vfs module file (virtual.ts beside this lane file):
+ * the report states the engine ships the vfs; a host whose module graph
+ * cannot load it answers the failure per run, never per report. */
+export declare function probevirtualmodule(): boolean;
+/** probes the s3 storage configuration the env carries (the runtime
+ * surface of the s3 vault lane): the endpoint, the credentials and the
+ * bucket — every required key present or the lane answers absent. */
+export declare function probes3config(): boolean;
+/** probes the libsql storage surface: the @libsql/client module the
+ * engine graph carries plus the LIBSQL_URL configuration — the honest
+ * present check of the libsql vault lane. */
+export declare function probelibsqlconfig(): boolean;
+/** probes the mysql storage surface: the mysql2 promise module plus the
+ * MYSQL_URL configuration — the honest present check of the mysql wire
+ * vault lane. */
+export declare function probemysqlconfig(): boolean;
+/** the lane executor table: every live lane and every host lane of the
+ * edge plane, keyed by modality id; the dispatch plane refuses to boot
+ * over a lane it cannot wire. */
+export declare const edgelaneexecutors: Readonly<Record<string, EdgeLaneExecutor>>;

package/dist/edgelandes.host.d.ts

@@ -0,0 +1,26 @@
+import { type EdgeLaneExecutor } from "./edgelandes.ts";
+/** one host lane declaration: the modality id, the kind (every lane
+ * here is live — the executor drives the runtime when present), the
+ * runtime surface it rides and the synchronous presence probe. */
+export interface HostLaneSpec {
+    /** the modality id the lane wires (the registry id). */
+    modality: string;
+    /** live lanes execute, host lanes probe (all twenty-five are live). */
+    kind: "live" | "host";
+    /** the runtime surface the lane rides ("bwrap", "docker", "tor"...). */
+    runtime: string;
+    /** the honest presence probe of the runtime on this engine host. */
+    present: () => boolean;
+}
+/** the host lane table of the ninety modalities wave, group a: the
+ * twenty-five host binary lanes, every one kind live — the executor
+ * exists and drives the runtime when the host carries it. The ids are
+ * pinned — the dispatcher merge and the api surface read them exactly. */
+export declare const hostlanespecs: readonly HostLaneSpec[];
+/** the host lane executor table: one executor per lane id, keyed by the
+ * modality id in the same order as the spec table; the dispatch plane
+ * refuses to boot over a lane it cannot wire. */
+export declare const edgelaneexecutorshost: Readonly<Record<string, EdgeLaneExecutor>>;
+/** the host lane ids in the spec order — the pinned contract the
+ * dispatcher merge and the api surface read exactly. */
+export declare const hostlaneids: readonly string[];