@rivet-dev/agentos-core 0.0.0-integrate-dylib-into-main.815fcda → 0.0.0-main.29b0797

package/dist/agentos-package.d.ts

@@ -0,0 +1,31 @@
+/**
+ * agentOS package model (Linux-exact, Homebrew-modeled) — client-facing surface.
+ *
+ * A package is a self-contained directory produced by `@rivet-dev/agentos-toolchain
+ * pack`. The HOST no longer projects it: the client forwards only the package
+ * directory over the wire and the secure-exec sidecar owns the `/opt/agentos`
+ * projection. Package metadata lives in `<dir>/agentos-package.json`.
+ *
+ * This module is therefore only the client-facing package-dir surface plus the
+ * `/opt/agentos` path constants used for agent-config wiring.
+ *
+ * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
+ */
+import type { AgentosPackageManifest, PackageAgentDescriptor, PackageRef as ManifestPackageRef } from "@agentos-software/manifest";
+/** Root of the agentOS package tree inside the VM. */
+export declare const OPT_AGENTOS_ROOT = "/opt/agentos";
+/** The symlink farm on `$PATH` (commands link here). */
+export declare const OPT_AGENTOS_BIN = "/opt/agentos/bin";
+export type AgentBlock = PackageAgentDescriptor;
+export type PackageRef = ManifestPackageRef;
+export type SoftwarePackageRef = {
+    packagePath: string;
+};
+/** Portable descriptor used to link a package into a running VM. */
+export interface PackageDescriptor {
+    path: string;
+}
+/** Discriminate the dir-only package reference. */
+export declare function isPackageDescriptor(value: unknown): value is PackageDescriptor;
+export declare function readAgentosPackageManifest(dir: string): AgentosPackageManifest;
+export declare function tryReadAgentosPackageManifest(dir: string): AgentosPackageManifest | undefined;

package/dist/agentos-package.js

@@ -0,0 +1,91 @@
+/**
+ * agentOS package model (Linux-exact, Homebrew-modeled) — client-facing surface.
+ *
+ * A package is a self-contained directory produced by `@rivet-dev/agentos-toolchain
+ * pack`. The HOST no longer projects it: the client forwards only the package
+ * directory over the wire and the secure-exec sidecar owns the `/opt/agentos`
+ * projection. Package metadata lives in `<dir>/agentos-package.json`.
+ *
+ * This module is therefore only the client-facing package-dir surface plus the
+ * `/opt/agentos` path constants used for agent-config wiring.
+ *
+ * See `website/src/content/docs/docs/architecture/packages-and-command-resolution.mdx`.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Root of the agentOS package tree inside the VM. */
+export const OPT_AGENTOS_ROOT = "/opt/agentos";
+/** The symlink farm on `$PATH` (commands link here). */
+export const OPT_AGENTOS_BIN = "/opt/agentos/bin";
+/** Discriminate the dir-only package reference. */
+export function isPackageDescriptor(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.path === "string");
+}
+export function readAgentosPackageManifest(dir) {
+    const manifestPath = join(dir, "agentos-package.json");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch (error) {
+        const wrapped = new Error(`Failed to read agentOS package manifest at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+        wrapped.code = error.code;
+        throw wrapped;
+    }
+    return validateAgentosPackageManifest(parsed, manifestPath);
+}
+export function tryReadAgentosPackageManifest(dir) {
+    try {
+        return readAgentosPackageManifest(dir);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function validateAgentosPackageManifest(value, source) {
+    if (!isPlainObject(value) || typeof value.name !== "string") {
+        throw new Error(`Invalid agentOS package manifest at ${source}: missing name`);
+    }
+    if (typeof value.version !== "string") {
+        throw new Error(`Invalid agentOS package manifest at ${source}: missing version`);
+    }
+    const manifest = {
+        name: value.name,
+        version: value.version,
+    };
+    if (value.agent !== undefined) {
+        if (!isPlainObject(value.agent) ||
+            typeof value.agent.acpEntrypoint !== "string") {
+            throw new Error(`Invalid agentOS package manifest at ${source}: invalid agent.acpEntrypoint`);
+        }
+        manifest.agent = {
+            acpEntrypoint: value.agent.acpEntrypoint,
+            ...(isStringRecord(value.agent.env) ? { env: value.agent.env } : {}),
+            ...(Array.isArray(value.agent.launchArgs) &&
+                value.agent.launchArgs.every((arg) => typeof arg === "string")
+                ? { launchArgs: value.agent.launchArgs }
+                : {}),
+            ...(typeof value.agent.snapshot === "boolean"
+                ? { snapshot: value.agent.snapshot }
+                : {}),
+        };
+    }
+    if (value.provides !== undefined) {
+        manifest.provides = value.provides;
+    }
+    return manifest;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return (isPlainObject(value) &&
+        Object.values(value).every((entry) => typeof entry === "string"));
+}

package/dist/base-filesystem.d.ts

@@ -1,5 +1,4 @@
-import { type FilesystemEntry } from "./filesystem-snapshot.js";
-import { type VirtualFileSystem } from "./runtime-compat.js";
+import type { FilesystemEntry } from "./filesystem-snapshot.js";
 export interface BaseFilesystemEnvironment {
     env: Record<string, string>;
     prompt: string;
@@ -18,17 +17,5 @@ export interface BaseFilesystemSnapshot {
         entries: BaseFilesystemEntry[];
     };
 }
-export declare function createBaseLowerFilesystem(): Promise<VirtualFileSystem>;
-export declare function createBootstrapAwareFilesystem(filesystem: VirtualFileSystem, existingRoot: VirtualFileSystem, options?: {
-    readOnlyAfterBootstrap?: boolean;
-}): {
-    filesystem: VirtualFileSystem;
-    finishKernelBootstrap: () => void;
-};
-export declare function getBaseFilesystemSnapshot(): BaseFilesystemSnapshot;
+/** The default VM environment (a fresh, mutable copy per call). */
 export declare function getBaseEnvironment(): Record<string, string>;
-export declare function getBaseFilesystemEntries(): BaseFilesystemEntry[];
-export declare function createBaseRootFilesystem(): Promise<{
-    filesystem: VirtualFileSystem;
-    finishKernelBootstrap: () => void;
-}>;

package/dist/base-filesystem.js

@@ -1,173 +1,25 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import * as posixPath from "node:path/posix";
-import { createFilesystemFromEntries, } from "./filesystem-snapshot.js";
-import { createOverlayBackend } from "./overlay-filesystem.js";
-import { KernelError } from "./runtime-compat.js";
-const require = createRequire(import.meta.url);
-const SNAPSHOT_PATH = require.resolve("@secure-exec/core/fixtures/base-filesystem.json");
-const SUPPRESSED_KERNEL_BOOTSTRAP_DIRS = new Set([
-    "/boot",
-    "/usr/games",
-    "/usr/include",
-    "/usr/libexec",
-    "/usr/man",
-]);
-const SUPPRESSED_KERNEL_BOOTSTRAP_FILES = new Set(["/usr/bin/env"]);
-let snapshotCache = null;
-function loadSnapshot() {
-    if (snapshotCache) {
-        return snapshotCache;
-    }
-    snapshotCache = JSON.parse(readFileSync(SNAPSHOT_PATH, "utf-8"));
-    return snapshotCache;
-}
-function normalizePath(path) {
-    const normalized = posixPath.normalize(path);
-    return normalized === "." ? "/" : normalized;
-}
-export async function createBaseLowerFilesystem() {
-    return createFilesystemFromEntries(getBaseFilesystemEntries());
-}
-export function createBootstrapAwareFilesystem(filesystem, existingRoot, options) {
-    let bootstrapActive = true;
-    let writesLocked = false;
-    function throwReadOnly() {
-        throw new KernelError("EROFS", "read-only file system");
-    }
-    async function rootHasPath(path) {
-        try {
-            return await existingRoot.exists(path);
-        }
-        catch {
-            return false;
-        }
-    }
-    const wrapped = {
-        ...filesystem,
-        async createDir(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_DIRS.has(normalized) &&
-                !(await rootHasPath(normalized))) {
-                return;
-            }
-            return filesystem.createDir(path);
-        },
-        async mkdir(path, options) {
-            if (writesLocked) {
-                if (options?.recursive && (await rootHasPath(path))) {
-                    return;
-                }
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                options?.recursive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_DIRS.has(normalized) &&
-                !(await rootHasPath(normalized))) {
-                return;
-            }
-            return filesystem.mkdir(path, options);
-        },
-        async writeFile(path, content) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            const normalized = normalizePath(path);
-            if (bootstrapActive &&
-                SUPPRESSED_KERNEL_BOOTSTRAP_FILES.has(normalized)) {
-                return;
-            }
-            return filesystem.writeFile(path, content);
-        },
-        async removeFile(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.removeFile(path);
-        },
-        async removeDir(path) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.removeDir(path);
-        },
-        async rename(oldPath, newPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.rename(oldPath, newPath);
-        },
-        async symlink(target, linkPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.symlink(target, linkPath);
-        },
-        async link(oldPath, newPath) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.link(oldPath, newPath);
-        },
-        async chmod(path, mode) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.chmod(path, mode);
-        },
-        async chown(path, uid, gid) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.chown(path, uid, gid);
-        },
-        async utimes(path, atime, mtime) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.utimes(path, atime, mtime);
-        },
-        async truncate(path, length) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.truncate(path, length);
-        },
-        async pwrite(path, offset, data) {
-            if (writesLocked) {
-                throwReadOnly();
-            }
-            return filesystem.pwrite(path, offset, data);
-        },
-    };
-    return {
-        filesystem: wrapped,
-        finishKernelBootstrap() {
-            bootstrapActive = false;
-            writesLocked = options?.readOnlyAfterBootstrap ?? false;
-        },
-    };
-}
-export function getBaseFilesystemSnapshot() {
-    return loadSnapshot();
-}
+/**
+ * The base VM environment, baked in as a constant (verbatim from the single
+ * `base-filesystem.json` the sidecar embeds). The host no longer reads that JSON
+ * — the sidecar owns the base filesystem, and there is exactly one committed copy
+ * of it (`secure-exec/crates/vfs/assets/base-filesystem.json`). Regenerate both
+ * this constant and that file together with the build-tools snapshot script.
+ */
+const BASE_ENVIRONMENT = Object.freeze({
+    CHARSET: "UTF-8",
+    HOME: "/home/agentos",
+    HOSTNAME: "secure-exec",
+    LANG: "C.UTF-8",
+    LC_COLLATE: "C",
+    LOGNAME: "agentos",
+    PAGER: "less",
+    PATH: "/usr/local/sbin:/usr/local/bin:/opt/agentos/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+    MANPATH: "/opt/agentos/share/man:/usr/local/share/man:/usr/share/man",
+    SHELL: "/bin/sh",
+    USER: "agentos",
+    PS1: "\\h:\\w\\$ ",
+});
+/** The default VM environment (a fresh, mutable copy per call). */
 export function getBaseEnvironment() {
-    const snapshot = loadSnapshot();
-    return {
-        ...snapshot.environment.env,
-        PS1: snapshot.environment.prompt,
-    };
-}
-export function getBaseFilesystemEntries() {
-    return loadSnapshot().filesystem.entries;
-}
-export async function createBaseRootFilesystem() {
-    const lower = await createBaseLowerFilesystem();
-    const overlay = createOverlayBackend({ lower });
-    return createBootstrapAwareFilesystem(overlay, lower);
+    return { ...BASE_ENVIRONMENT };
 }

package/dist/{host-tools-zod.d.ts → bindings-zod.d.ts}

@@ -1,5 +1,5 @@
 import type { ZodType } from "zod";
-export declare class HostToolSchemaConversionError extends Error {
+export declare class BindingSchemaConversionError extends Error {
     readonly path: string;
     readonly zodType: string;
     constructor(path: string, zodType: string, details?: string);

package/dist/{host-tools-zod.js → bindings-zod.js}

@@ -1,3 +1,4 @@
+import { zodToJsonSchema as zodV3ToJsonSchema } from "zod-to-json-schema";
 const OPTIONAL_WRAPPER_TYPES = new Set(["default", "optional"]);
 const TRANSPARENT_WRAPPER_TYPES = new Set([
     ...OPTIONAL_WRAPPER_TYPES,
@@ -14,7 +15,7 @@ const UNSUPPORTED_TYPES = new Set([
     "pipe",
     "tuple",
 ]);
-export class HostToolSchemaConversionError extends Error {
+export class BindingSchemaConversionError extends Error {
     path;
     zodType;
     constructor(path, zodType, details) {
@@ -24,12 +25,15 @@ export class HostToolSchemaConversionError extends Error {
         ]
             .filter(Boolean)
             .join(" "));
-        this.name = "HostToolSchemaConversionError";
+        this.name = "BindingSchemaConversionError";
         this.path = path;
         this.zodType = zodType;
     }
 }
 function getSchemaDef(schema) {
+    if (!schema || typeof schema !== "object") {
+        return {};
+    }
     return (schema._def ??
         schema.def ??
         {});
@@ -46,7 +50,10 @@ function normalizeTypeName(schema) {
     if (constructorName === "discriminatedunion" || "discriminator" in def) {
         return "discriminatedunion";
     }
-    const rawTypeName = String(def.typeName ?? def.type ?? schema.type ?? constructorName);
+    const rawTypeName = String(def.typeName ??
+        def.type ??
+        schema.type ??
+        constructorName);
     return rawTypeName.replace(/^Zod/, "").toLowerCase();
 }
 function displayTypeName(typeName) {
@@ -89,24 +96,24 @@ function isCustomRefinement(check) {
 }
 function validateChecks(schema, path, typeName) {
     if (getChecks(schema).some(isCustomRefinement)) {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "custom refinements cannot be represented faithfully in JSON Schema");
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName), "custom refinements cannot be represented faithfully in JSON Schema");
     }
 }
 function validateSchema(schema, path) {
     const typeName = normalizeTypeName(schema);
     if (metadataProducesRefs(schema)) {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "metadata that emits $ref/$defs is not supported");
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName), "metadata that emits $ref/$defs is not supported");
     }
     if (UNSUPPORTED_TYPES.has(typeName)) {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName));
     }
     if (typeName === "discriminatedunion") {
-        throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+        throw new BindingSchemaConversionError(path, displayTypeName(typeName));
     }
     if (TRANSPARENT_WRAPPER_TYPES.has(typeName)) {
         const inner = getInnerSchema(schema);
         if (!inner) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "wrapper schema is missing its inner schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "wrapper schema is missing its inner schema");
         }
         validateSchema(inner, path);
         return;
@@ -114,7 +121,7 @@ function validateSchema(schema, path) {
     if (typeName === "nullable") {
         const inner = getInnerSchema(schema);
         if (!inner) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "nullable schema is missing its inner schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "nullable schema is missing its inner schema");
         }
         validateSchema(inner, path);
         return;
@@ -131,9 +138,10 @@ function validateSchema(schema, path) {
         return;
     }
     if (typeName === "array") {
-        const itemSchema = getSchemaDef(schema).element;
+        const def = getSchemaDef(schema);
+        const itemSchema = (def.element ?? def.type);
         if (!itemSchema) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "array schema is missing its item schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "array schema is missing its item schema");
         }
         validateSchema(itemSchema, `${path}[]`);
         return;
@@ -143,11 +151,11 @@ function validateSchema(schema, path) {
         const keySchema = def.keyType;
         const valueSchema = def.valueType;
         if (!keySchema || !valueSchema) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "record schema is missing its key or value schema");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "record schema is missing its key or value schema");
         }
         const keyTypeName = normalizeTypeName(keySchema);
         if (keyTypeName !== "string" || getChecks(keySchema).length > 0) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "record keys must be unconstrained strings");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "record keys must be unconstrained strings");
         }
         validateSchema(valueSchema, `${path}<record-value>`);
         return;
@@ -155,7 +163,7 @@ function validateSchema(schema, path) {
     if (typeName === "union") {
         const options = getSchemaDef(schema).options;
         if (!Array.isArray(options) || options.length === 0) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "union schema is missing its options");
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "union schema is missing its options");
         }
         for (let index = 0; index < options.length; index += 1) {
             validateSchema(options[index], `${path}<union:${index}>`);
@@ -163,12 +171,17 @@ function validateSchema(schema, path) {
         return;
     }
     if (typeName === "literal") {
-        const values = getSchemaDef(schema).values;
-        const literalValues = Array.isArray(values) ? values : [];
+        const def = getSchemaDef(schema);
+        const literalValues = Array.isArray(def.values)
+            ? def.values
+            : "value" in def
+                ? [def.value]
+                : [];
         const [literalValue] = literalValues;
         if (literalValues.length !== 1 ||
-            !("string number boolean".split(" ").includes(typeof literalValue) || literalValue === null)) {
-            throw new HostToolSchemaConversionError(path, displayTypeName(typeName), "literal values must be JSON primitives");
+            !("string number boolean".split(" ").includes(typeof literalValue) ||
+                literalValue === null)) {
+            throw new BindingSchemaConversionError(path, displayTypeName(typeName), "literal values must be JSON primitives");
         }
         return;
     }
@@ -179,7 +192,7 @@ function validateSchema(schema, path) {
         typeName === "nativeenum") {
         return;
     }
-    throw new HostToolSchemaConversionError(path, displayTypeName(typeName));
+    throw new BindingSchemaConversionError(path, displayTypeName(typeName));
 }
 function sanitizeJsonSchema(value) {
     if (Array.isArray(value)) {
@@ -194,7 +207,9 @@ function sanitizeJsonSchema(value) {
         if (key === "$schema") {
             continue;
         }
-        if (key === "additionalProperties" && entry === false && record.type === "object") {
+        if (key === "additionalProperties" &&
+            entry === false &&
+            record.type === "object") {
             continue;
         }
         sanitized[key] = sanitizeJsonSchema(entry);
@@ -225,15 +240,27 @@ function findUnsupportedGeneratedKeyword(value, path) {
     }
     return null;
 }
+function generateJsonSchema(schema) {
+    const nativeJsonSchema = schema.toJSONSchema?.();
+    if (nativeJsonSchema) {
+        return nativeJsonSchema;
+    }
+    const generated = zodV3ToJsonSchema(schema, {
+        $refStrategy: "none",
+        target: "jsonSchema7",
+    });
+    if (!generated ||
+        (typeof generated === "object" && Object.keys(generated).length === 0)) {
+        throw new BindingSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), "schema cannot be converted to JSON Schema");
+    }
+    return generated;
+}
 export function zodToJsonSchema(schema) {
     validateSchema(schema, "$");
-    const jsonSchema = schema.toJSONSchema?.();
-    if (!jsonSchema) {
-        throw new HostToolSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), "schema does not expose toJSONSchema()");
-    }
+    const jsonSchema = generateJsonSchema(schema);
     const unsupportedKeyword = findUnsupportedGeneratedKeyword(jsonSchema, "$");
     if (unsupportedKeyword) {
-        throw new HostToolSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), `${unsupportedKeyword.keyword} emitted at ${unsupportedKeyword.path} is not supported`);
+        throw new BindingSchemaConversionError("$", displayTypeName(normalizeTypeName(schema)), `${unsupportedKeyword.keyword} emitted at ${unsupportedKeyword.path} is not supported`);
     }
     const sanitized = sanitizeJsonSchema(jsonSchema);
     const description = getDescription(schema);

package/dist/bindings.d.ts

@@ -0,0 +1,43 @@
+import type { ZodType } from "zod";
+/** Maximum length for binding descriptions (characters). */
+export declare const MAX_BINDING_DESCRIPTION_LENGTH = 200;
+/**
+ * A single binding that executes on the host.
+ */
+export interface Binding<INPUT = any, OUTPUT = any> {
+    /** Description shown to the agent in --help and prompt docs. Max 200 characters. */
+    description: string;
+    /** Zod schema for the input. Drives CLI flag generation and validation. */
+    inputSchema: ZodType<INPUT>;
+    /** Runs on the host when the agent invokes the binding. */
+    execute: (input: INPUT) => Promise<OUTPUT> | OUTPUT;
+    /** Examples included in auto-generated prompt docs. */
+    examples?: BindingExample<INPUT>[];
+    /** Timeout in ms. Default: 30000. */
+    timeout?: number;
+}
+export interface BindingExample<INPUT = any> {
+    /** Human description of what this example does. */
+    description: string;
+    /** The input args for the example. */
+    input: INPUT;
+}
+/**
+ * A named collection of bindings. Becomes a CLI binary: agentos-{name}.
+ */
+export interface Bindings {
+    /** Collection name. Must be lowercase alphanumeric + hyphens. Becomes the CLI suffix: agentos-{name}. */
+    name: string;
+    /** Description shown in `agentos list-bindings` and prompt docs. */
+    description: string;
+    /** The bindings in this collection. Keys become subcommands. */
+    bindings: Record<string, Binding>;
+}
+/** Helper to create a binding with type inference. */
+export declare function binding<INPUT, OUTPUT>(def: Binding<INPUT, OUTPUT>): Binding<INPUT, OUTPUT>;
+/** Helper to create a named binding collection. */
+export declare function bindings(def: Bindings): Bindings;
+/**
+ * Validate every binding collection and binding.
+ */
+export declare function validateBindings(collections: Bindings[]): void;

package/dist/bindings.js

@@ -0,0 +1,34 @@
+/** Maximum length for binding descriptions (characters). */
+export const MAX_BINDING_DESCRIPTION_LENGTH = 200;
+/** Helper to create a binding with type inference. */
+export function binding(def) {
+    return def;
+}
+/** Helper to create a named binding collection. */
+export function bindings(def) {
+    return def;
+}
+const BINDING_COMMAND_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function validateBindingCommandName(kind, name) {
+    if (BINDING_COMMAND_NAME_RE.test(name)) {
+        return;
+    }
+    throw new Error(`${kind} name "${name}" must be lowercase alphanumeric with optional single hyphen separators`);
+}
+/**
+ * Validate every binding collection and binding.
+ */
+export function validateBindings(collections) {
+    for (const collection of collections) {
+        validateBindingCommandName("Binding collection", collection.name);
+        if (collection.description.length > MAX_BINDING_DESCRIPTION_LENGTH) {
+            throw new Error(`Binding collection "${collection.name}" description is ${collection.description.length} characters, max is ${MAX_BINDING_DESCRIPTION_LENGTH}`);
+        }
+        for (const [bindingName, definition] of Object.entries(collection.bindings)) {
+            validateBindingCommandName("Binding", bindingName);
+            if (definition.description.length > MAX_BINDING_DESCRIPTION_LENGTH) {
+                throw new Error(`Binding "${collection.name}/${bindingName}" description is ${definition.description.length} characters, max is ${MAX_BINDING_DESCRIPTION_LENGTH}`);
+            }
+        }
+    }
+}