@forthix/forthic 0.2.0 → 0.4.0

package/README.md

@@ -1,16 +1,16 @@
 # Forthic TypeScript Runtime
 
-**A TypeScript/JavaScript runtime for [Forthic](https://github.com/forthix/forthic)** - the stack-based, concatenative language for composable transformations.
+**A TypeScript/JavaScript runtime for [Forthic](https://github.com/forthix/forthic)** - *the* stack-based, concatenative language for composable transformations.
 
-Use Forthic to wrap your TypeScript/JavaScript code in composable transformations, leveraging categorical principles for clean, powerful abstractions.
+Use Forthic to wrap your TypeScript/JavaScript code within composable words, leveraging categorical principles for clean, powerful abstractions.
 
-**[Main Forthic Documentation](https://github.com/forthix/forthic)** | **[Getting Started](#getting-started)** | **[Examples](examples/)** | **[API Docs](docs/)**
+**[Forthic Parent Documentation](https://github.com/forthix/forthic)** | **[Getting Started with forthic-ts](#getting-started)** | **[Examples](examples/)** | **[API Docs](docs/)**
 
 ---
 
 ## What is Forthic?
 
-Forthic enables **categorical coding** - using Category Theory principles to build composable transformations. This TypeScript runtime lets you:
+Forthic enables **categorical coding** - a way to solve problems by viewing them in terms of trasnformation rather than copmutation. This TypeScript runtime lets you:
 
 1. **Wrap existing code** with simple decorators
 2. **Compose transformations** cleanly using stack-based operations
@@ -55,9 +55,9 @@ const interp = new Interpreter();
 interp.register_module(new AnalyticsModule());
 
 await interp.run(`
-  ["analytics"] USE_MODULES
+  ["analytics"] USE-MODULES
 
-  [1 2 3 100 4 5] 2 FILTER-OUTLIERS analytics.AVERAGE
+  [1 2 3 100 4 5] 2 FILTER-OUTLIERS AVERAGE
 `);
 
 const result = interp.stack_pop(); // Clean average without outliers
@@ -132,12 +132,12 @@ const interp = new Interpreter();
 interp.register_module(new MyModule());
 
 await interp.run(`
-  ["mymodule"] USE_MODULES
+  ["mymodule"] USE-MODULES
   SOME-DATA PROCESS
 `);
 ```
 
-See [docs/getting-started.md](docs/getting-started.md) for detailed tutorial.
+See [examples/README.md](examples/README.md) for detailed tutorials and examples.
 
 ---
 
@@ -162,7 +162,7 @@ See [docs/modules/](docs/modules/) for complete reference.
 The `@Word` decorator makes wrapping code trivial:
 
 ```typescript
-@Word("( input:type -- output:type )", "Description")
+@Word("( input:type -- output:type )", "Description", "MY-WORD")
 async MY_WORD(input: any) {
   return yourLogic(input);
 }
@@ -175,19 +175,27 @@ async MY_WORD(input: any) {
 - Browser and Node.js compatible
 - Supports async/await
 
-### Composition-First Design
+
+### Package Exports
+
+forthic-ts provides multiple import paths for different use cases:
 
 ```typescript
-// Build higher-level abstractions through composition
-await interp.run(`
-  : CLEAN-AVERAGE   2 analytics.FILTER-OUTLIERS analytics.AVERAGE ;
+// Main package - Core interpreter and standard library (works everywhere)
+import { Interpreter, DecoratedModule, Word } from '@forthix/forthic';
 
-  dataset-1 CLEAN-AVERAGE
-  dataset-2 CLEAN-AVERAGE
-  dataset-3 CLEAN-AVERAGE
-`);
+// WebSocket support - Browser-compatible multi-runtime execution
+import { ActionCableClient, WebSocketRemoteModule } from '@forthix/forthic/websocket';
+
+// gRPC support - Node.js-only multi-runtime execution
+import { GrpcClient, RemoteModule, startGrpcServer } from '@forthix/forthic/grpc';
 ```
 
+**Environment Compatibility**:
+- **Main package** (`@forthix/forthic`): Works in both Node.js and browsers
+- **WebSocket** (`@forthix/forthic/websocket`): Works in both Node.js and browsers
+- **gRPC** (`@forthix/forthic/grpc`): Node.js only (requires `@grpc/grpc-js`)
+
 ---
 
 ## Documentation
@@ -207,57 +215,7 @@ await interp.run(`
 
 ## Examples
 
-### Data Transformation Pipeline
-
-```typescript
-await interp.run(`
-  data-records
-    'DUP "score" REC@ 80 >' SELECT    # Filter records with score > 80
-    '"name" REC@' MAP                  # Extract names
-    'UPPERCASE' MAP                    # Convert to uppercase
-    ', ' JOIN                          # Join into comma-separated string
-`);
-```
-
-### Wrapping Business Logic
-
-```typescript
-export class OrderModule extends DecoratedModule {
-  constructor(private orderService: OrderService) {
-    super("orders");
-  }
-
-  @Word("( order:object -- validatedOrder:object )", "Validate order")
-  async VALIDATE(order: any) {
-    return this.orderService.validate(order);
-  }
-
-  @Word("( order:object -- orderWithTax:object )", "Calculate tax")
-  async CALCULATE_TAX(order: any) {
-    return this.orderService.calculateTax(order);
-  }
-
-  @Word("( order:object -- submittedOrder:object )", "Submit order")
-  async SUBMIT(order: any) {
-    return this.orderService.submit(order);
-  }
-}
-
-// Compose into high-level workflow
-await interp.run(`
-  ["orders"] USE_MODULES
-
-  : PROCESS-ORDER
-      VALIDATE
-      CALCULATE-TAX
-      SUBMIT
-  ;
-
-  new-order PROCESS-ORDER
-`);
-```
-
-More examples in [examples/](examples/) directory.
+See examples in the [examples](examples/) directory.
 
 ---
 
@@ -279,13 +237,45 @@ npm run docs:build
 
 ---
 
-## Multi-Runtime Vision
+## Multi-Runtime Execution
+
+Call code from other language runtimes seamlessly - use Python's pandas from TypeScript, or TypeScript's fs module from Ruby.
+
+### Quick Example
+
+```typescript
+import { Interpreter } from '@forthix/forthic';
+import { GrpcClient, RemoteModule } from '@forthix/forthic/grpc';
+
+const interp = new Interpreter();
+
+// Connect to Python runtime
+const client = new GrpcClient('localhost:50051');
+const pandas = new RemoteModule('pandas', client, 'python');
+await pandas.initialize();
+
+interp.register_module(pandas);
+
+// Now use Python pandas from TypeScript!
+await interp.run(`["pandas"] USE-MODULES  [records] DF-FROM-RECORDS`);
+```
+
+### Approaches
+
+- **gRPC** - Node.js ↔ Python ↔ Ruby (fast, server-to-server)
+- **WebSocket** - Browser ↔ Rails (ActionCable, client-server)
+
+### Learn More
 
-Forthic is designed to work **seamlessly across multiple runtimes** (TypeScript, Java, Python, Ruby, .NET). Call Java modules from TypeScript, Python ML models from .NET - all transparently.
+📖 **[Complete Multi-Runtime Documentation](docs/multi-runtime/)**
 
-See [Multi-Runtime Architecture](https://github.com/forthix/forthic/tree/main/docs/multi-runtime) for the vision.
+- **[Overview](docs/multi-runtime/)** - When and how to use multi-runtime
+- **[gRPC Setup](docs/multi-runtime/grpc.md)** - Server and client configuration
+- **[WebSocket Setup](docs/multi-runtime/websocket.md)** - Browser-compatible communication
+- **[Configuration](docs/multi-runtime/configuration.md)** - YAML config and connection management
+- **[Examples](examples/)** - Working code samples (05-grpc-server.ts, 06-grpc-client.ts)
 
-**Status:** TypeScript runtime is active. Java in progress. Python, Ruby, .NET planned.
+**Runtime Status:** ✅ TypeScript, Python, Ruby | 🚧 Rust | 📋 Java, .NET
 
 ---
 
@@ -322,4 +312,4 @@ Also see the [main Forthic contributing guide](https://github.com/forthix/forthi
 
 ---
 
-**Forthic TypeScript: Wrap your code. Compose transformations. Build powerful abstractions.**
+**Forthic**: Wrap. Compose. Abstract.

package/dist/cjs/common/temporal_utils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Temporal Type Utilities
+ *
+ * Provides duck-typing helpers for checking Temporal types.
+ * Uses duck typing instead of instanceof to avoid issues with multiple
+ * instances of temporal-polyfill being loaded.
+ */
+/**
+ * Check if a value is a Temporal.PlainDate
+ * PlainDate has year, month, day properties but no hour property
+ */
+export declare function isPlainDate(value: any): boolean;
+/**
+ * Check if a value is a Temporal.Instant
+ * Instant has epochNanoseconds property as a bigint
+ */
+export declare function isInstant(value: any): boolean;
+/**
+ * Check if a value is a Temporal.ZonedDateTime
+ * ZonedDateTime has a timeZoneId property
+ */
+export declare function isZonedDateTime(value: any): boolean;
+/**
+ * Check if a value is a Temporal.PlainTime
+ * PlainTime has hour and minute properties but no year
+ */
+export declare function isPlainTime(value: any): boolean;
+/**
+ * Check if a value is a Temporal.PlainDateTime
+ * PlainDateTime has year, month, day, hour properties but no timeZoneId
+ */
+export declare function isPlainDateTime(value: any): boolean;
+/**
+ * Check if a value is any Temporal type
+ */
+export declare function isTemporal(value: any): boolean;

package/dist/cjs/common/temporal_utils.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Temporal Type Utilities
+ *
+ * Provides duck-typing helpers for checking Temporal types.
+ * Uses duck typing instead of instanceof to avoid issues with multiple
+ * instances of temporal-polyfill being loaded.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainDate = isPlainDate;
+exports.isInstant = isInstant;
+exports.isZonedDateTime = isZonedDateTime;
+exports.isPlainTime = isPlainTime;
+exports.isPlainDateTime = isPlainDateTime;
+exports.isTemporal = isTemporal;
+/**
+ * Check if a value is a Temporal.PlainDate
+ * PlainDate has year, month, day properties but no hour property
+ */
+function isPlainDate(value) {
+    return value && typeof value === 'object' &&
+        typeof value.year === 'number' &&
+        typeof value.month === 'number' &&
+        typeof value.day === 'number' &&
+        typeof value.toString === 'function' &&
+        !value.hour; // PlainDate doesn't have hour
+}
+/**
+ * Check if a value is a Temporal.Instant
+ * Instant has epochNanoseconds property as a bigint
+ */
+function isInstant(value) {
+    return value && typeof value === 'object' &&
+        typeof value.epochNanoseconds === 'bigint' &&
+        typeof value.toString === 'function';
+}
+/**
+ * Check if a value is a Temporal.ZonedDateTime
+ * ZonedDateTime has a timeZoneId property
+ */
+function isZonedDateTime(value) {
+    return value && typeof value === 'object' &&
+        typeof value.timeZoneId === 'string' &&
+        typeof value.toString === 'function';
+}
+/**
+ * Check if a value is a Temporal.PlainTime
+ * PlainTime has hour and minute properties but no year
+ */
+function isPlainTime(value) {
+    return value && typeof value === 'object' &&
+        typeof value.hour === 'number' &&
+        typeof value.minute === 'number' &&
+        typeof value.toString === 'function' &&
+        !value.year; // PlainTime doesn't have year
+}
+/**
+ * Check if a value is a Temporal.PlainDateTime
+ * PlainDateTime has year, month, day, hour properties but no timeZoneId
+ */
+function isPlainDateTime(value) {
+    return value && typeof value === 'object' &&
+        typeof value.year === 'number' &&
+        typeof value.month === 'number' &&
+        typeof value.day === 'number' &&
+        typeof value.hour === 'number' &&
+        typeof value.toString === 'function' &&
+        !value.timeZoneId; // PlainDateTime doesn't have timeZoneId
+}
+/**
+ * Check if a value is any Temporal type
+ */
+function isTemporal(value) {
+    return isPlainDate(value) ||
+        isInstant(value) ||
+        isZonedDateTime(value) ||
+        isPlainTime(value) ||
+        isPlainDateTime(value);
+}
+//# sourceMappingURL=temporal_utils.js.map

package/dist/cjs/common/temporal_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal_utils.js","sourceRoot":"","sources":["../../../src/common/temporal_utils.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAMH,kCAOC;AAMD,8BAIC;AAMD,0CAIC;AAMD,kCAMC;AAMD,0CAQC;AAKD,gCAMC;AApED;;;GAGG;AACH,SAAgB,WAAW,CAAC,KAAU;IACpC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAClC,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;QAC/B,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ;QAC7B,OAAO,KAAK,CAAC,QAAQ,KAAK,UAAU;QACpC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAE,8BAA8B;AACrD,CAAC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAAC,KAAU;IAClC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAClC,OAAO,KAAK,CAAC,gBAAgB,KAAK,QAAQ;QAC1C,OAAO,KAAK,CAAC,QAAQ,KAAK,UAAU,CAAC;AAC9C,CAAC;AAED;;;GAGG;AACH,SAAgB,eAAe,CAAC,KAAU;IACxC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAClC,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ;QACpC,OAAO,KAAK,CAAC,QAAQ,KAAK,UAAU,CAAC;AAC9C,CAAC;AAED;;;GAGG;AACH,SAAgB,WAAW,CAAC,KAAU;IACpC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAClC,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ;QAChC,OAAO,KAAK,CAAC,QAAQ,KAAK,UAAU;QACpC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAE,8BAA8B;AACrD,CAAC;AAED;;;GAGG;AACH,SAAgB,eAAe,CAAC,KAAU;IACxC,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAClC,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;QAC/B,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ;QAC7B,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,OAAO,KAAK,CAAC,QAAQ,KAAK,UAAU;QACpC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAE,wCAAwC;AACrE,CAAC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAC,KAAU;IACnC,OAAO,WAAW,CAAC,KAAK,CAAC;QAClB,SAAS,CAAC,KAAK,CAAC;QAChB,eAAe,CAAC,KAAK,CAAC;QACtB,WAAW,CAAC,KAAK,CAAC;QAClB,eAAe,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC"}

package/dist/cjs/common/type_utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared type detection utilities for Forthic value serialization
+ * Used by both gRPC and WebSocket serializers
+ */
+/**
+ * Forthic value types
+ */
+export type ForthicType = 'null' | 'boolean' | 'integer' | 'float' | 'string' | 'array' | 'record' | 'instant' | 'plain_date' | 'zoned_datetime';
+/**
+ * Get the Forthic type of a JavaScript value
+ * Determines the correct serialization type for a value
+ *
+ * IMPORTANT: Order matters!
+ * - Check temporal types BEFORE primitives (they're objects)
+ * - Check ZonedDateTime BEFORE Instant (ZonedDateTime may match isInstant)
+ * - Check boolean BEFORE number (to avoid typeof confusion)
+ * - Check array BEFORE object (arrays are objects)
+ */
+export declare function getForthicType(value: any): ForthicType;
+/**
+ * Check if a value is a temporal type
+ */
+export declare function isTemporalType(value: any): boolean;
+/**
+ * Check if a value is a primitive type (not array or record)
+ */
+export declare function isPrimitive(value: any): boolean;
+/**
+ * Check if a value is a container type (array or record)
+ */
+export declare function isContainer(value: any): boolean;

package/dist/cjs/common/type_utils.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Shared type detection utilities for Forthic value serialization
+ * Used by both gRPC and WebSocket serializers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getForthicType = getForthicType;
+exports.isTemporalType = isTemporalType;
+exports.isPrimitive = isPrimitive;
+exports.isContainer = isContainer;
+const temporal_utils_js_1 = require("./temporal_utils.js");
+/**
+ * Get the Forthic type of a JavaScript value
+ * Determines the correct serialization type for a value
+ *
+ * IMPORTANT: Order matters!
+ * - Check temporal types BEFORE primitives (they're objects)
+ * - Check ZonedDateTime BEFORE Instant (ZonedDateTime may match isInstant)
+ * - Check boolean BEFORE number (to avoid typeof confusion)
+ * - Check array BEFORE object (arrays are objects)
+ */
+function getForthicType(value) {
+    // Handle null/undefined
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    // Handle Temporal types (check ZonedDateTime BEFORE Instant)
+    if ((0, temporal_utils_js_1.isZonedDateTime)(value)) {
+        return 'zoned_datetime';
+    }
+    if ((0, temporal_utils_js_1.isInstant)(value)) {
+        return 'instant';
+    }
+    if ((0, temporal_utils_js_1.isPlainDate)(value)) {
+        return 'plain_date';
+    }
+    // Handle boolean (check before number)
+    if (typeof value === 'boolean') {
+        return 'boolean';
+    }
+    // Handle number (distinguish integer vs float)
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? 'integer' : 'float';
+    }
+    // Handle string
+    if (typeof value === 'string') {
+        return 'string';
+    }
+    // Handle array (check before object)
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    // Handle object/record
+    if (typeof value === 'object') {
+        return 'record';
+    }
+    throw new Error(`Unsupported value type: ${typeof value}`);
+}
+/**
+ * Check if a value is a temporal type
+ */
+function isTemporalType(value) {
+    return (0, temporal_utils_js_1.isInstant)(value) || (0, temporal_utils_js_1.isPlainDate)(value) || (0, temporal_utils_js_1.isZonedDateTime)(value);
+}
+/**
+ * Check if a value is a primitive type (not array or record)
+ */
+function isPrimitive(value) {
+    const type = getForthicType(value);
+    return type !== 'array' && type !== 'record';
+}
+/**
+ * Check if a value is a container type (array or record)
+ */
+function isContainer(value) {
+    const type = getForthicType(value);
+    return type === 'array' || type === 'record';
+}
+//# sourceMappingURL=type_utils.js.map

package/dist/cjs/common/type_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_utils.js","sourceRoot":"","sources":["../../../src/common/type_utils.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AA8BH,wCA6CC;AAKD,wCAEC;AAKD,kCAGC;AAKD,kCAGC;AA/FD,2DAA8E;AAiB9E;;;;;;;;;GASG;AACH,SAAgB,cAAc,CAAC,KAAU;IACvC,wBAAwB;IACxB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QAC1C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,6DAA6D;IAC7D,IAAI,IAAA,mCAAe,EAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,IAAI,IAAA,6BAAS,EAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,IAAA,+BAAW,EAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,uCAAuC;IACvC,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,+CAA+C;IAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;IACvD,CAAC;IAED,gBAAgB;IAChB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,qCAAqC;IACrC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,uBAAuB;IACvB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,KAAK,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,KAAU;IACvC,OAAO,IAAA,6BAAS,EAAC,KAAK,CAAC,IAAI,IAAA,+BAAW,EAAC,KAAK,CAAC,IAAI,IAAA,mCAAe,EAAC,KAAK,CAAC,CAAC;AAC1E,CAAC;AAED;;GAEG;AACH,SAAgB,WAAW,CAAC,KAAU;IACpC,MAAM,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACnC,OAAO,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,QAAQ,CAAC;AAC/C,CAAC;AAED;;GAEG;AACH,SAAgB,WAAW,CAAC,KAAU;IACpC,MAAM,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACnC,OAAO,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,QAAQ,CAAC;AAC/C,CAAC"}

package/dist/cjs/forthic/decorators/word.d.ts

@@ -10,7 +10,7 @@ export interface ModuleMetadata {
     examples: string[];
 }
 /**
- * @DirectWord Decorator
+ * @ForthicDirectWord Decorator
  *
  * Auto-registers word but does NOT handle stack marshalling.
  * Use this for words that need direct interpreter access to manually manipulate the stack.
@@ -21,16 +21,16 @@ export interface ModuleMetadata {
  * @param customWordName - Optional custom word name (defaults to method name)
  *
  * @example
- * @DirectWord("( item:any forthic:string num:number -- )", "Repeat execution num_times", "<REPEAT")
+ * @ForthicDirectWord("( item:any forthic:string num:number -- )", "Repeat execution num_times", "<REPEAT")
  * async l_REPEAT(interp: Interpreter) {
  *   const num = interp.stack_pop();
  *   const forthic = interp.stack_pop();
  *   // ... manual stack manipulation
  * }
  */
-export declare function DirectWord(stackEffect: string, description?: string, customWordName?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ForthicDirectWord(stackEffect: string, description?: string, customWordName?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**
- * @Word Decorator
+ * @ForthicWord Decorator
  *
  * Auto-registers word and handles stack marshalling.
  * Word name defaults to method name, but can be overridden.
@@ -40,18 +40,18 @@ export declare function DirectWord(stackEffect: string, description?: string, cu
  * @param customWordName - Optional custom word name (defaults to method name)
  *
  * @example
- * @Word("( a:number b:number -- sum:number )", "Adds two numbers")
+ * @ForthicWord("( a:number b:number -- sum:number )", "Adds two numbers")
  * async ADD(a: number, b: number) {
  *   return a + b;
  * }
  *
  * @example
- * @Word("( rec:any field:any -- value:any )", "Get value from record", "REC@")
+ * @ForthicWord("( rec:any field:any -- value:any )", "Get value from record", "REC@")
  * async REC_at(rec: any, field: any) {
  *   // Word name will be "REC@" instead of "REC_at"
  * }
  */
-export declare function Word(stackEffect: string, description?: string, customWordName?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function ForthicWord(stackEffect: string, description?: string, customWordName?: string): (target: any, propertyKey: string, descriptor?: PropertyDescriptor) => PropertyDescriptor;
 /**
  * Helper function to register module documentation
  *
@@ -78,6 +78,14 @@ export declare class DecoratedModule extends Module {
     constructor(name: string);
     set_interp(interp: Interpreter): void;
     private registerDecoratedWords;
+    /**
+     * Add a standard library word that can execute in any runtime
+     *
+     * This creates a word marked with isStandard=true, allowing it to be
+     * included in batched remote execution (e.g., +, MAP, REVERSE can execute
+     * in Python runtime along with Python-specific words).
+     */
+    private add_standard_word;
     /**
      * Get documentation for all words in this module
      *