@astrale-os/sdk 0.6.0-beta.4 → 0.6.0-beta.6

package/dist/application/workflow/runner/inline.js

@@ -1,5 +1,5 @@
-import * as value from '../../../platform/value/index.js';
 import { acceptStepId } from '../step/index.js';
+import { acceptStepOutput } from '../step/output.js';
 /** Process-local runner for tests and explicitly non-durable embeddings. */
 export function createInlineWorkflowRunner() {
     async function run(workflow, context) {
@@ -37,10 +37,8 @@ function createInlineStep(signal) {
             started.add(accepted);
             execution = (async () => {
                 const output = await execute();
-                if (output === undefined)
-                    return output;
                 try {
-                    return value.accept(output);
+                    return acceptStepOutput(output);
                 }
                 catch (cause) {
                     throw new TypeError(`Workflow Step ${accepted} output must be portable.`, {

package/dist/application/workflow/step/output.d.ts

@@ -0,0 +1,2 @@
+/** Capture optional Object fields as absence without changing portable Array or scalar semantics. */
+export declare function acceptStepOutput<Output>(input: Output): Output;

package/dist/application/workflow/step/output.js

@@ -0,0 +1,73 @@
+import * as value from '../../../platform/value/index.js';
+/** Capture optional Object fields as absence without changing portable Array or scalar semantics. */
+export function acceptStepOutput(input) {
+    if (input === undefined)
+        return input;
+    const captured = new WeakMap();
+    const omitted = new WeakMap();
+    const pending = [];
+    let members = 0;
+    function capture(source, depth) {
+        if (source === null || typeof source !== 'object')
+            return source;
+        const retained = captured.get(source);
+        if (retained !== undefined)
+            return retained;
+        if (depth >= value.defaultLimits.maxDepth) {
+            throw new value.BoundaryError('VALUE_LIMIT', 'Workflow Step container depth exceeds the portable limit', '');
+        }
+        const array = Array.isArray(source);
+        const snapshot = array ? [] : Object.create(Object.getPrototypeOf(source));
+        captured.set(source, snapshot);
+        pending.push({ source, snapshot, depth, array });
+        return snapshot;
+    }
+    const snapshot = capture(input, 0);
+    for (let index = 0; index < pending.length; index += 1) {
+        const { source, snapshot: container, depth, array } = pending[index];
+        const descriptors = Object.getOwnPropertyDescriptors(source);
+        const keys = Reflect.ownKeys(descriptors);
+        // Bound this preparatory capture too; canonical admission subsequently checks each path.
+        members += keys.length - (array ? 1 : 0);
+        if (members > value.defaultLimits.maxMembers) {
+            throw new value.BoundaryError('VALUE_LIMIT', 'Workflow Step member count exceeds the portable limit', '');
+        }
+        const absent = new Set();
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(descriptors, key)
+                .value;
+            if ('value' in descriptor) {
+                if (!array &&
+                    typeof key === 'string' &&
+                    descriptor.enumerable &&
+                    descriptor.value === undefined) {
+                    // Validate this member's key, descriptor and budget before interpreting its absence.
+                    descriptor.value = null;
+                    absent.add(key);
+                }
+                else {
+                    descriptor.value = capture(descriptor.value, depth + 1);
+                }
+            }
+            Object.defineProperty(container, key, descriptor);
+        }
+        if (absent.size > 0)
+            omitted.set(container, absent);
+    }
+    // The canonical owner still rejects cycles, invalid descriptors/prototypes/keys and lossy values.
+    const output = value.accept(snapshot);
+    const pruning = [{ snapshot, output }];
+    for (let index = 0; index < pruning.length; index += 1) {
+        const pair = pruning[index];
+        if (pair.output === null || typeof pair.output !== 'object')
+            continue;
+        const source = pair.snapshot;
+        const target = pair.output;
+        for (const key of omitted.get(source) ?? [])
+            delete target[key];
+        for (const key of Object.keys(target)) {
+            pruning.push({ snapshot: source[key], output: target[key] });
+        }
+    }
+    return output;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.6.0-beta.4",
+  "version": "0.6.0-beta.6",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",