@rolexjs/prototype 0.12.0-dev-20260228032306

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+import { State, Runtime, Structure } from '@rolexjs/system';
+import { ResourceX } from 'resourcexjs';
+
+declare const processes: Record<string, string>;
+declare const world: Record<string, string>;
+
+/**
+ * Dispatch — schema-driven argument mapping.
+ *
+ * Replaces the hand-written toArgs switch in rolex.ts with a single
+ * lookup against the instruction registry.
+ */
+/**
+ * Map named arguments to positional arguments for a given operation.
+ *
+ * @param op - Operation key in "namespace.method" format (e.g. "individual.born")
+ * @param args - Named arguments from the caller
+ * @returns Positional argument array matching the method signature
+ */
+declare function toArgs(op: string, args: Record<string, unknown>): unknown[];
+
+/**
+ * Schema types for RoleX instruction definitions.
+ *
+ * These types define the structure of every RoleX operation:
+ * parameter types, descriptions, and positional arg ordering.
+ */
+/** Supported parameter types for instruction definitions. */
+type ParamType = "string" | "gherkin" | "string[]" | "record";
+/** Definition of a single parameter in an instruction. */
+interface ParamDef {
+    type: ParamType;
+    required: boolean;
+    description: string;
+}
+/**
+ * A single positional argument entry.
+ *
+ * - `string` — simple lookup: `args[name]`
+ * - `{ pack: [...] }` — collect named args into an options object;
+ *   returns `undefined` if all values are absent.
+ */
+type ArgEntry = string | {
+    pack: readonly string[];
+};
+/** Full definition of a RoleX instruction (one namespace.method). */
+interface InstructionDef {
+    namespace: string;
+    method: string;
+    /** Parameter definitions — keyed by param name, used for MCP/CLI schema generation. */
+    params: Record<string, ParamDef>;
+    /** Positional argument order — maps named args to method call positions. */
+    args: readonly ArgEntry[];
+}
+
+/**
+ * Instruction set — schema definitions for all RoleX operations.
+ *
+ * Covers every namespace.method that can be dispatched through `use()`.
+ */
+
+declare const instructions: Record<string, InstructionDef>;
+
+/**
+ * Ops — platform-agnostic operation implementations.
+ *
+ * Every RoleX operation is a pure function of (Runtime, args) → OpResult.
+ * No platform-specific code — all I/O goes through injected interfaces.
+ *
+ * Usage:
+ *   const ops = createOps({ rt, society, past, resolve, find, resourcex });
+ *   const result = ops["individual.born"]("Feature: Sean", "sean");
+ */
+
+interface OpResult {
+    state: State;
+    process: string;
+}
+interface OpsContext {
+    rt: Runtime;
+    society: Structure;
+    past: Structure;
+    resolve(id: string): Structure;
+    find(id: string): Structure | null;
+    resourcex?: ResourceX;
+    prototype?: {
+        settle(id: string, source: string): void;
+        evict(id: string): void;
+        list(): Record<string, string>;
+    };
+    direct?(locator: string, args?: Record<string, unknown>): Promise<unknown>;
+}
+type Ops = Record<string, (...args: any[]) => any>;
+declare function createOps(ctx: OpsContext): Ops;
+
+export { type ArgEntry, type InstructionDef, type OpResult, type Ops, type OpsContext, type ParamDef, type ParamType, createOps, instructions, processes, toArgs, world };