@hotmeshio/hotmesh 0.12.1 → 0.14.0

package/build/services/durable/workflow/searchMethods.js

@@ -51,6 +51,13 @@ const common_1 = require("./common");
  * }
  * ```
  *
+ * **Not available with `workerCredentials`.** This method writes directly
+ * to the `jobs` and `jobs_attributes` tables, bypassing the SECURITY
+ * DEFINER stored procedures that scoped worker roles are restricted to.
+ * Workers connecting with `workerCredentials` will receive a permission
+ * error. Use `search()` only in workflows running with full database
+ * credentials.
+ *
  * @returns {Promise<Search>} A search session scoped to the current workflow job.
  */
 async function search() {

package/build/services/durable/workflow/signal.d.ts

@@ -1,11 +1,11 @@
 /**
  * Sends a signal payload to a paused workflow thread that is awaiting this
- * `signalId` via `waitFor()`. Signals are the primary mechanism for
+ * `signalId` via `condition()`. Signals are the primary mechanism for
  * inter-workflow communication and for delivering results from hook
  * functions back to the orchestrating workflow.
  *
  * `signal` is the **send** side of the coordination pair. The **receive**
- * side is `waitFor()`. A signal can be sent from:
+ * side is `condition()`. A signal can be sent from:
  * - Another workflow function
  * - A hook function (most common pattern with `execHook`)
  * - An external client via `Durable.Client.workflow.signal()`
@@ -40,7 +40,7 @@
  *   const { prepareData } = Durable.workflow.proxyActivities<typeof activities>();
  *   const data = await prepareData();
  *
- *   // Signal another workflow that is paused on waitFor('data-ready')
+ *   // Signal another workflow that is paused on condition('data-ready')
  *   await Durable.workflow.signal('data-ready', { payload: data });
  * }
  * ```
@@ -51,7 +51,7 @@
  * await client.workflow.signal('approval-signal', { approved: true });
  * ```
  *
- * @param {string} signalId - Unique signal identifier that matches a `waitFor()` call.
+ * @param {string} signalId - Unique signal identifier that matches a `condition()` call.
  * @param {Record<any, any>} data - The payload to deliver to the waiting workflow.
  * @returns {Promise<string>} The resulting hook/stream ID.
  */

package/build/services/durable/workflow/signal.js

@@ -5,12 +5,12 @@ const common_1 = require("./common");
 const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
 /**
  * Sends a signal payload to a paused workflow thread that is awaiting this
- * `signalId` via `waitFor()`. Signals are the primary mechanism for
+ * `signalId` via `condition()`. Signals are the primary mechanism for
  * inter-workflow communication and for delivering results from hook
  * functions back to the orchestrating workflow.
  *
  * `signal` is the **send** side of the coordination pair. The **receive**
- * side is `waitFor()`. A signal can be sent from:
+ * side is `condition()`. A signal can be sent from:
  * - Another workflow function
  * - A hook function (most common pattern with `execHook`)
  * - An external client via `Durable.Client.workflow.signal()`
@@ -45,7 +45,7 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  *   const { prepareData } = Durable.workflow.proxyActivities<typeof activities>();
  *   const data = await prepareData();
  *
- *   // Signal another workflow that is paused on waitFor('data-ready')
+ *   // Signal another workflow that is paused on condition('data-ready')
  *   await Durable.workflow.signal('data-ready', { payload: data });
  * }
  * ```
@@ -56,7 +56,7 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  * await client.workflow.signal('approval-signal', { approved: true });
  * ```
  *
- * @param {string} signalId - Unique signal identifier that matches a `waitFor()` call.
+ * @param {string} signalId - Unique signal identifier that matches a `condition()` call.
  * @param {Record<any, any>} data - The payload to deliver to the waiting workflow.
  * @returns {Promise<string>} The resulting hook/stream ID.
  */

package/build/services/durable/workflow/{sleepFor.d.ts → sleep.d.ts}

@@ -3,7 +3,7 @@
  * `setTimeout`, this sleep survives process restarts — the engine persists
  * the wake-up time and resumes the workflow when the timer expires.
  *
- * On replay, `sleepFor` returns immediately with the stored duration
+ * On replay, `sleep` returns immediately with the stored duration
  * (no actual waiting occurs). This makes it safe for deterministic
  * re-execution.
  *
@@ -23,11 +23,11 @@
  *   const { sendReminder } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   // Wait 24 hours (survives server restarts)
- *   await Durable.workflow.sleepFor('24 hours');
+ *   await Durable.workflow.sleep('24 hours');
  *   await sendReminder(userId, 'Your trial expires tomorrow');
  *
  *   // Wait another 6 days
- *   await Durable.workflow.sleepFor('6 days');
+ *   await Durable.workflow.sleep('6 days');
  *   await sendReminder(userId, 'Your trial has expired');
  * }
  * ```
@@ -43,7 +43,7 @@
  *
  *     // Exponential backoff: 1s, 2s, 4s, 8s, ...
  *     const delay = Math.pow(2, attempt);
- *     await Durable.workflow.sleepFor(`${delay} seconds`);
+ *     await Durable.workflow.sleep(`${delay} seconds`);
  *   }
  *   return 'timeout';
  * }
@@ -53,11 +53,11 @@
  * // Race a sleep against an activity
  * const [result, _] = await Promise.all([
  *   activities.fetchData(id),
- *   Durable.workflow.sleepFor('30 seconds'),
+ *   Durable.workflow.sleep('30 seconds'),
  * ]);
  * ```
  *
- * @param {string} duration - A human-readable duration string.
+ * @param {string | number} duration - A human-readable duration string (e.g., `'30s'`, `'5 minutes'`) or milliseconds as a number.
  * @returns {Promise<number>} The resolved duration in seconds.
  */
-export declare function sleepFor(duration: string): Promise<number>;
+export declare function sleep(duration: string | number): Promise<number>;

package/build/services/durable/workflow/{sleepFor.js → sleep.js}

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleepFor = void 0;
+exports.sleep = void 0;
 const common_1 = require("./common");
+const cancellationScope_1 = require("./cancellationScope");
 const didRun_1 = require("./didRun");
 /**
  * Suspends workflow execution for a durable, crash-safe duration. Unlike
  * `setTimeout`, this sleep survives process restarts — the engine persists
  * the wake-up time and resumes the workflow when the timer expires.
  *
- * On replay, `sleepFor` returns immediately with the stored duration
+ * On replay, `sleep` returns immediately with the stored duration
  * (no actual waiting occurs). This makes it safe for deterministic
  * re-execution.
  *
@@ -28,11 +29,11 @@ const didRun_1 = require("./didRun");
  *   const { sendReminder } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   // Wait 24 hours (survives server restarts)
- *   await Durable.workflow.sleepFor('24 hours');
+ *   await Durable.workflow.sleep('24 hours');
  *   await sendReminder(userId, 'Your trial expires tomorrow');
  *
  *   // Wait another 6 days
- *   await Durable.workflow.sleepFor('6 days');
+ *   await Durable.workflow.sleep('6 days');
  *   await sendReminder(userId, 'Your trial has expired');
  * }
  * ```
@@ -48,7 +49,7 @@ const didRun_1 = require("./didRun");
  *
  *     // Exponential backoff: 1s, 2s, 4s, 8s, ...
  *     const delay = Math.pow(2, attempt);
- *     await Durable.workflow.sleepFor(`${delay} seconds`);
+ *     await Durable.workflow.sleep(`${delay} seconds`);
  *   }
  *   return 'timeout';
  * }
@@ -58,25 +59,53 @@ const didRun_1 = require("./didRun");
  * // Race a sleep against an activity
  * const [result, _] = await Promise.all([
  *   activities.fetchData(id),
- *   Durable.workflow.sleepFor('30 seconds'),
+ *   Durable.workflow.sleep('30 seconds'),
  * ]);
  * ```
  *
- * @param {string} duration - A human-readable duration string.
+ * @param {string | number} duration - A human-readable duration string (e.g., `'30s'`, `'5 minutes'`) or milliseconds as a number.
  * @returns {Promise<number>} The resolved duration in seconds.
  */
-async function sleepFor(duration) {
+async function sleep(duration) {
+    // Normalize: number input is treated as milliseconds (Temporal compat)
+    const durationStr = typeof duration === 'number' ? `${duration} milliseconds` : duration;
     const [didRunAlready, execIndex, result] = await (0, didRun_1.didRun)('sleep');
+    (0, cancellationScope_1.checkCancellation)();
     if (didRunAlready) {
+        // Emit RETURN span in debug mode
+        if (common_1.DurableTelemetryService.isVerbose() && result) {
+            const store = common_1.asyncLocalStorage.getStore();
+            const workflowTrace = store.get('workflowTrace');
+            const workflowSpan = store.get('workflowSpan');
+            if (workflowTrace && workflowSpan && result.ac && result.au) {
+                common_1.DurableTelemetryService.emitDurationSpan(workflowTrace, workflowSpan, `RETURN/sleep/${durationStr}/${execIndex}`, common_1.DurableTelemetryService.parseTimestamp(result.ac), common_1.DurableTelemetryService.parseTimestamp(result.au), {
+                    'durable.operation.type': 'sleep',
+                    'durable.sleep.duration': durationStr,
+                    'durable.exec.index': execIndex,
+                });
+            }
+        }
         return result.duration;
     }
     const store = common_1.asyncLocalStorage.getStore();
+    // Emit DISPATCH span in debug mode
+    if (common_1.DurableTelemetryService.isVerbose()) {
+        const workflowTrace = store.get('workflowTrace');
+        const workflowSpan = store.get('workflowSpan');
+        if (workflowTrace && workflowSpan) {
+            common_1.DurableTelemetryService.emitPointSpan(workflowTrace, workflowSpan, `DISPATCH/sleep/${durationStr}/${execIndex}`, {
+                'durable.operation.type': 'sleep',
+                'durable.sleep.duration': durationStr,
+                'durable.exec.index': execIndex,
+            });
+        }
+    }
     const interruptionRegistry = store.get('interruptionRegistry');
     const workflowId = store.get('workflowId');
     const workflowDimension = store.get('workflowDimension') ?? '';
     const interruptionMessage = {
         workflowId,
-        duration: (0, common_1.s)(duration),
+        duration: (0, common_1.s)(durationStr),
         index: execIndex,
         workflowDimension,
     };
@@ -88,4 +117,4 @@ async function sleepFor(duration) {
     await (0, common_1.sleepImmediate)();
     throw new common_1.DurableSleepError(interruptionMessage);
 }
-exports.sleepFor = sleepFor;
+exports.sleep = sleep;

package/build/services/durable/workflow/terminate.d.ts

@@ -0,0 +1,55 @@
+import { JobInterruptOptions } from './common';
+/**
+ * Terminates a running workflow job by its ID. The target job's status
+ * is set to an error code indicating abnormal termination, and any
+ * pending activities or timers are cancelled.
+ *
+ * This is the workflow-internal terminate — it can only be called from
+ * within a workflow function. For external termination, use
+ * `handle.terminate()` directly.
+ *
+ * The terminate fires exactly once per workflow execution — the
+ * `isSideEffectAllowed` guard prevents re-terminating on replay.
+ *
+ * ## Examples
+ *
+ * ```typescript
+ * import { Durable } from '@hotmeshio/hotmesh';
+ *
+ * // Terminate a child workflow from the parent
+ * export async function supervisorWorkflow(): Promise<void> {
+ *   const childId = await Durable.workflow.startChild({
+ *     taskQueue: 'workers',
+ *     workflowName: 'longTask',
+ *     args: [],
+ *   });
+ *
+ *   // Wait for a timeout, then terminate the child
+ *   await Durable.workflow.sleep('5 minutes');
+ *   await Durable.workflow.terminate(childId, {
+ *     reason: 'Timed out waiting for child',
+ *     descend: true,     // also terminate any grandchild workflows
+ *   });
+ * }
+ * ```
+ *
+ * ```typescript
+ * // Self-terminate on validation failure
+ * export async function validatedWorkflow(input: string): Promise<void> {
+ *   const { workflowId } = Durable.workflow.workflowInfo();
+ *   const { validate } = Durable.workflow.proxyActivities<typeof activities>();
+ *
+ *   const isValid = await validate(input);
+ *   if (!isValid) {
+ *     await Durable.workflow.terminate(workflowId, {
+ *       reason: 'Invalid input',
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @param {string} jobId - The ID of the workflow job to terminate.
+ * @param {JobInterruptOptions} [options={}] - Termination options (`reason`, `descend`, etc.).
+ * @returns {Promise<string | void>} The result of the termination, if any.
+ */
+export declare function terminate(jobId: string, options?: JobInterruptOptions): Promise<string | void>;

package/build/services/durable/workflow/{interrupt.js → terminate.js}

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.interrupt = void 0;
+exports.terminate = void 0;
 const common_1 = require("./common");
-const context_1 = require("./context");
+const workflowInfo_1 = require("./workflowInfo");
 const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
 /**
  * Terminates a running workflow job by its ID. The target job's status
  * is set to an error code indicating abnormal termination, and any
  * pending activities or timers are cancelled.
  *
- * This is the workflow-internal interrupt — it can only be called from
- * within a workflow function. For external interruption, use
- * `hotMesh.interrupt()` directly.
+ * This is the workflow-internal terminate — it can only be called from
+ * within a workflow function. For external termination, use
+ * `handle.terminate()` directly.
  *
- * The interrupt fires exactly once per workflow execution — the
- * `isSideEffectAllowed` guard prevents re-interrupting on replay.
+ * The terminate fires exactly once per workflow execution — the
+ * `isSideEffectAllowed` guard prevents re-terminating on replay.
  *
  * ## Examples
  *
  * ```typescript
  * import { Durable } from '@hotmeshio/hotmesh';
  *
- * // Cancel a child workflow from the parent
+ * // Terminate a child workflow from the parent
  * export async function supervisorWorkflow(): Promise<void> {
  *   const childId = await Durable.workflow.startChild({
  *     taskQueue: 'workers',
@@ -29,36 +29,36 @@ const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
  *     args: [],
  *   });
  *
- *   // Wait for a timeout, then cancel the child
- *   await Durable.workflow.sleepFor('5 minutes');
- *   await Durable.workflow.interrupt(childId, {
+ *   // Wait for a timeout, then terminate the child
+ *   await Durable.workflow.sleep('5 minutes');
+ *   await Durable.workflow.terminate(childId, {
  *     reason: 'Timed out waiting for child',
- *     descend: true,     // also interrupt any grandchild workflows
+ *     descend: true,     // also terminate any grandchild workflows
  *   });
  * }
  * ```
  *
  * ```typescript
- * // Self-interrupt on validation failure
+ * // Self-terminate on validation failure
  * export async function validatedWorkflow(input: string): Promise<void> {
- *   const { workflowId } = Durable.workflow.getContext();
+ *   const { workflowId } = Durable.workflow.workflowInfo();
  *   const { validate } = Durable.workflow.proxyActivities<typeof activities>();
  *
  *   const isValid = await validate(input);
  *   if (!isValid) {
- *     await Durable.workflow.interrupt(workflowId, {
+ *     await Durable.workflow.terminate(workflowId, {
  *       reason: 'Invalid input',
  *     });
  *   }
  * }
  * ```
  *
- * @param {string} jobId - The ID of the workflow job to interrupt.
- * @param {JobInterruptOptions} [options={}] - Interruption options (`reason`, `descend`, etc.).
- * @returns {Promise<string | void>} The result of the interruption, if any.
+ * @param {string} jobId - The ID of the workflow job to terminate.
+ * @param {JobInterruptOptions} [options={}] - Termination options (`reason`, `descend`, etc.).
+ * @returns {Promise<string | void>} The result of the termination, if any.
  */
-async function interrupt(jobId, options = {}) {
-    const { workflowTopic, connection, namespace } = (0, context_1.getContext)();
+async function terminate(jobId, options = {}) {
+    const { workflowTopic, connection, namespace } = (0, workflowInfo_1.workflowInfo)();
     const hotMeshClient = await common_1.WorkerService.getHotMesh(workflowTopic, {
         connection,
         namespace,
@@ -67,4 +67,4 @@ async function interrupt(jobId, options = {}) {
         return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);
     }
 }
-exports.interrupt = interrupt;
+exports.terminate = terminate;

package/build/services/durable/workflow/trace.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trace = void 0;
 const common_1 = require("./common");
-const context_1 = require("./context");
+const workflowInfo_1 = require("./workflowInfo");
 const isSideEffectAllowed_1 = require("./isSideEffectAllowed");
 /**
  * Emits a distributed trace span to the configured telemetry sink
@@ -56,7 +56,7 @@ async function trace(attributes, config = { once: true }) {
         connection,
         namespace,
     });
-    const { raw, COUNTER } = (0, context_1.getContext)();
+    const { raw, COUNTER } = (0, workflowInfo_1.workflowInfo)();
     const { trc: traceId, spn: spanId, aid: activityId } = raw.metadata;
     if (!config.once || await (0, isSideEffectAllowed_1.isSideEffectAllowed)(hotMeshClient, 'trace')) {
         return await common_1.TelemetryService.traceActivity(namespace, attributes, activityId, traceId, spanId, COUNTER.counter);

package/build/services/durable/workflow/uuid4.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a deterministic UUID v4 string. The value is derived from the
+ * current execution counter, producing the **same UUID** on every replay.
+ *
+ * Use this instead of `crypto.randomUUID()` inside workflow functions.
+ *
+ * ```typescript
+ * const id = Durable.workflow.uuid4();
+ * // e.g. "a3b8f042-1e9c-4d5a-b6e7-3f2c8a9d0e1b"
+ * ```
+ *
+ * @returns {string} A deterministic UUID v4 string.
+ */
+export declare function uuid4(): string;

package/build/services/durable/workflow/uuid4.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid4 = void 0;
+const common_1 = require("./common");
+/**
+ * Returns a deterministic UUID v4 string. The value is derived from the
+ * current execution counter, producing the **same UUID** on every replay.
+ *
+ * Use this instead of `crypto.randomUUID()` inside workflow functions.
+ *
+ * ```typescript
+ * const id = Durable.workflow.uuid4();
+ * // e.g. "a3b8f042-1e9c-4d5a-b6e7-3f2c8a9d0e1b"
+ * ```
+ *
+ * @returns {string} A deterministic UUID v4 string.
+ */
+function uuid4() {
+    const store = common_1.asyncLocalStorage.getStore();
+    const COUNTER = store.get('counter');
+    // Generate 16 deterministic pseudo-random bytes
+    const bytes = [];
+    for (let i = 0; i < 16; i++) {
+        const seed = COUNTER.counter = COUNTER.counter + 1;
+        bytes.push(Math.floor((0, common_1.deterministicRandom)(seed) * 256));
+    }
+    // Set version (4) and variant (RFC 4122)
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.map(b => b.toString(16).padStart(2, '0'));
+    return [
+        hex.slice(0, 4).join(''),
+        hex.slice(4, 6).join(''),
+        hex.slice(6, 8).join(''),
+        hex.slice(8, 10).join(''),
+        hex.slice(10, 16).join(''),
+    ].join('-');
+}
+exports.uuid4 = uuid4;

package/build/services/durable/workflow/{context.d.ts → workflowInfo.d.ts}

@@ -15,7 +15,7 @@ import { WorkflowContext } from './common';
  *
  * // Access the workflow ID and namespace
  * export async function contextAwareWorkflow(): Promise<string> {
- *   const ctx = Durable.workflow.getContext();
+ *   const ctx = Durable.workflow.workflowInfo();
  *   console.log(`Running workflow ${ctx.workflowId} in ${ctx.namespace}`);
  *   return ctx.workflowId;
  * }
@@ -24,7 +24,7 @@ import { WorkflowContext } from './common';
  * ```typescript
  * // Check if the current execution is a replay
  * export async function replayAwareWorkflow(): Promise<void> {
- *   const { counter, workflowDimension } = Durable.workflow.getContext();
+ *   const { counter, workflowDimension } = Durable.workflow.workflowInfo();
  *
  *   // Use context for logging/debugging
  *   console.log(`Execution counter: ${counter}, dimension: ${workflowDimension}`);
@@ -34,9 +34,9 @@ import { WorkflowContext } from './common';
  * ```typescript
  * // Pass context info to child workflows
  * export async function parentWorkflow(): Promise<void> {
- *   const { workflowId } = Durable.workflow.getContext();
+ *   const { workflowId } = Durable.workflow.workflowInfo();
  *
- *   await Durable.workflow.execChild({
+ *   await Durable.workflow.executeChild({
  *     taskQueue: 'children',
  *     workflowName: 'childWorkflow',
  *     args: [workflowId],  // pass parent ID to child
@@ -46,4 +46,4 @@ import { WorkflowContext } from './common';
  *
  * @returns {WorkflowContext} The current workflow context.
  */
-export declare function getContext(): WorkflowContext;
+export declare function workflowInfo(): WorkflowContext;

package/build/services/durable/workflow/{context.js → workflowInfo.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContext = void 0;
+exports.workflowInfo = void 0;
 const common_1 = require("./common");
 /**
  * Returns the current workflow's execution context, providing access to
@@ -18,7 +18,7 @@ const common_1 = require("./common");
  *
  * // Access the workflow ID and namespace
  * export async function contextAwareWorkflow(): Promise<string> {
- *   const ctx = Durable.workflow.getContext();
+ *   const ctx = Durable.workflow.workflowInfo();
  *   console.log(`Running workflow ${ctx.workflowId} in ${ctx.namespace}`);
  *   return ctx.workflowId;
  * }
@@ -27,7 +27,7 @@ const common_1 = require("./common");
  * ```typescript
  * // Check if the current execution is a replay
  * export async function replayAwareWorkflow(): Promise<void> {
- *   const { counter, workflowDimension } = Durable.workflow.getContext();
+ *   const { counter, workflowDimension } = Durable.workflow.workflowInfo();
  *
  *   // Use context for logging/debugging
  *   console.log(`Execution counter: ${counter}, dimension: ${workflowDimension}`);
@@ -37,9 +37,9 @@ const common_1 = require("./common");
  * ```typescript
  * // Pass context info to child workflows
  * export async function parentWorkflow(): Promise<void> {
- *   const { workflowId } = Durable.workflow.getContext();
+ *   const { workflowId } = Durable.workflow.workflowInfo();
  *
- *   await Durable.workflow.execChild({
+ *   await Durable.workflow.executeChild({
  *     taskQueue: 'children',
  *     workflowName: 'childWorkflow',
  *     args: [workflowId],  // pass parent ID to child
@@ -49,7 +49,7 @@ const common_1 = require("./common");
  *
  * @returns {WorkflowContext} The current workflow context.
  */
-function getContext() {
+function workflowInfo() {
     const store = common_1.asyncLocalStorage.getStore();
     const workflowId = store.get('workflowId');
     const replay = store.get('replay');
@@ -87,4 +87,4 @@ function getContext() {
         workflowSpan,
     };
 }
-exports.getContext = getContext;
+exports.workflowInfo = workflowInfo;

package/build/services/engine/compiler.d.ts

@@ -0,0 +1,19 @@
+/**
+ * YAML app compilation and deployment.
+ *
+ * Thin delegation to CompilerService — kept as a separate module
+ * so the engine index reads as a clear list of capabilities.
+ */
+import { StoreService } from '../store';
+import { StreamService } from '../stream';
+import { ILogger } from '../logger';
+import { HotMeshManifest } from '../../types/hotmesh';
+import { ProviderClient, ProviderTransaction } from '../../types/provider';
+interface CompilerContext {
+    store: StoreService<ProviderClient, ProviderTransaction>;
+    stream: StreamService<ProviderClient, ProviderTransaction>;
+    logger: ILogger;
+}
+export declare function plan(instance: CompilerContext, pathOrYAML: string): Promise<HotMeshManifest>;
+export declare function deploy(instance: CompilerContext, pathOrYAML: string): Promise<HotMeshManifest>;
+export {};

package/build/services/engine/compiler.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * YAML app compilation and deployment.
+ *
+ * Thin delegation to CompilerService — kept as a separate module
+ * so the engine index reads as a clear list of capabilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = exports.plan = void 0;
+const compiler_1 = require("../compiler");
+async function plan(instance, pathOrYAML) {
+    const compiler = new compiler_1.CompilerService(instance.store, instance.stream, instance.logger);
+    return await compiler.plan(pathOrYAML);
+}
+exports.plan = plan;
+async function deploy(instance, pathOrYAML) {
+    const compiler = new compiler_1.CompilerService(instance.store, instance.stream, instance.logger);
+    return await compiler.deploy(pathOrYAML);
+}
+exports.deploy = deploy;

package/build/services/engine/completion.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Job lifecycle completion — parent notification, cleanup, and expiry.
+ *
+ * When a job finishes (or is interrupted), this module:
+ * 1. Notifies the parent job (if this is a child via execChild)
+ * 2. Publishes to one-time and permanent subscribers
+ * 3. Registers the job for TTL-based cleanup
+ */
+import { Router } from '../router';
+import { StoreService } from '../store';
+import { StreamService } from '../stream';
+import { SubService } from '../sub';
+import { TaskService } from '../task';
+import { ILogger } from '../logger';
+import { AppVID } from '../../types/app';
+import { JobState, JobOutput, JobMetadata, JobCompletionOptions, JobInterruptOptions } from '../../types/job';
+import { ProviderClient, ProviderTransaction } from '../../types/provider';
+import { StreamError } from '../../types/stream';
+interface CompletionContext {
+    appId: string;
+    store: StoreService<ProviderClient, ProviderTransaction>;
+    stream: StreamService<ProviderClient, ProviderTransaction>;
+    subscribe: SubService<ProviderClient>;
+    router: Router<typeof this.stream> | null;
+    taskService: TaskService;
+    logger: ILogger;
+    getVID(vid?: AppVID): Promise<AppVID>;
+    getState(topic: string, jobId: string): Promise<JobOutput>;
+    getPublishesTopic(context: JobState): Promise<string>;
+}
+/**
+ * Sends the child job result back to the waiting parent activity.
+ * Only applies to non-severed children (execChild, not startChild).
+ */
+export declare function execAdjacentParent(instance: CompletionContext, context: JobState, jobOutput: JobOutput, emit?: boolean, transaction?: ProviderTransaction): Promise<string>;
+export declare function hasParentJob(context: JobState, checkSevered?: boolean): boolean;
+export declare function resolveError(metadata: JobMetadata): StreamError | undefined;
+export declare function interrupt(instance: CompletionContext, topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
+export declare function scrub(instance: CompletionContext, jobId: string): Promise<void>;
+/**
+ * Orchestrates all post-completion work for a finished job:
+ * notify parent, publish to subscribers, schedule cleanup.
+ */
+export declare function runJobCompletionTasks(instance: CompletionContext, context: JobState, options?: JobCompletionOptions, transaction?: ProviderTransaction): Promise<string | void>;
+export declare function resolveExpires(context: JobState, options: JobCompletionOptions): number;
+export {};