@undefineds.co/xpod 0.4.20 → 0.4.27

package/dist/api/runs/ConditionalResourceDocument.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateConditionalResource = updateConditionalResource;
+exports.resourceLiteral = resourceLiteral;
+const n3_1 = require("n3");
+const sparqljs_1 = require("sparqljs");
+/** Temporary exact-write adapter; see docs/issues/2026-10-02-approval-conditional-update.md. */
+async function updateConditionalResource(input) {
+    const url = new URL(input.iri);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password)
+        throw new Error('Run resource must be an HTTP(S) IRI');
+    url.hash = '';
+    const documentUrl = url.href;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        const response = await input.fetch(documentUrl, {
+            headers: { accept: 'text/turtle' }, cache: 'no-store', redirect: 'error',
+        });
+        if (!response.ok)
+            throw new Error(`Run document read failed: HTTP ${response.status}`);
+        const etag = response.headers.get('etag');
+        const text = await response.text();
+        if (!etag || !/^"[^"\r\n]+"$/.test(etag))
+            throw new Error('Run updates require a strong document ETag');
+        if (!response.headers.get('content-type')?.toLowerCase().includes('text/turtle'))
+            throw new Error('Run updates require a Turtle document');
+        const quads = new n3_1.Parser({ baseIRI: documentUrl }).parse(text);
+        const update = input.update(quads);
+        if (!update.values)
+            return update.result;
+        const inserted = insertQuads(input.serialize(update.values), documentUrl, input.iri);
+        const changedPredicates = new Set(Object.keys(update.values).map(key => input.columns[key]?.options.predicate).filter(Boolean));
+        const inlinePredicates = new Set(Object.keys(update.values)
+            .filter(key => ['object', 'json', 'array'].includes(input.columns[key]?.dataType))
+            .map(key => input.columns[key]?.options.predicate).filter(Boolean));
+        const owned = new Set();
+        const keyOf = (term) => `${term.termType}:${term.value}`;
+        const isOwned = (term) => term.termType === 'BlankNode'
+            || (term.termType === 'NamedNode' && term.value.startsWith(`${input.iri}/`));
+        for (const quad of quads) {
+            if (quad.subject.value === input.iri && inlinePredicates.has(quad.predicate.value) && isOwned(quad.object))
+                owned.add(keyOf(quad.object));
+        }
+        let size = -1;
+        while (size !== owned.size) {
+            size = owned.size;
+            for (const quad of quads)
+                if (owned.has(keyOf(quad.subject)) && isOwned(quad.object))
+                    owned.add(keyOf(quad.object));
+        }
+        const preserved = quads.filter(quad => !owned.has(keyOf(quad.subject))
+            && !(quad.subject.value === input.iri && changedPredicates.has(quad.predicate.value)));
+        const store = new n3_1.Store([...preserved, ...inserted]);
+        const body = await new Promise((resolve, reject) => {
+            const writer = new n3_1.Writer({ format: 'Turtle' });
+            writer.addQuads(store.getQuads(null, null, null, null));
+            writer.end((error, output) => error ? reject(error) : resolve(output));
+        });
+        const result = await input.fetch(documentUrl, {
+            method: 'PUT', headers: { 'content-type': 'text/turtle', 'if-match': etag }, body, redirect: 'error',
+        });
+        await result.arrayBuffer();
+        if (result.status === 412)
+            continue; // Re-read and recompute; never replay stale state.
+        if (!result.ok)
+            throw new Error(`Run document update failed: HTTP ${result.status}`);
+        return update.result;
+    }
+    throw new Error('Run document changed repeatedly during conditional update');
+}
+function resourceLiteral(quads, iri, predicate) {
+    const values = quads.filter(quad => quad.subject.termType === 'NamedNode' && quad.subject.value === iri && quad.predicate.value === predicate);
+    if (values.length > 1 || values.some(quad => quad.object.termType !== 'Literal'))
+        throw new Error('Ambiguous Run lifecycle state');
+    return values[0]?.object.value;
+}
+function insertQuads(query, documentUrl, iri) {
+    const parsed = new sparqljs_1.Parser().parse(query);
+    if (parsed.type !== 'update')
+        throw new Error('Expected ORM INSERT serialization');
+    const output = [];
+    for (const update of parsed.updates) {
+        if (!('updateType' in update) || update.updateType !== 'insert')
+            throw new Error('Expected ORM INSERT DATA serialization');
+        for (const graph of update.insert) {
+            if (graph.type !== 'graph' || graph.name.termType !== 'NamedNode' || graph.name.value !== documentUrl)
+                throw new Error('ORM serialization escaped the Run document');
+            for (const triple of graph.triples) {
+                if (triple.subject.termType !== 'BlankNode' && (triple.subject.termType !== 'NamedNode'
+                    || !(triple.subject.value === iri || triple.subject.value.startsWith(`${iri}/`))))
+                    throw new Error('ORM serialization escaped the Run resource');
+                if (!('termType' in triple.predicate) || triple.predicate.termType !== 'NamedNode'
+                    || triple.object.termType === 'Variable')
+                    throw new Error('Expected concrete RDF triples');
+                output.push(n3_1.DataFactory.quad(triple.subject, triple.predicate, triple.object));
+            }
+        }
+    }
+    return output;
+}
+//# sourceMappingURL=ConditionalResourceDocument.js.map

package/dist/api/runs/EmbeddedInngestService.d.ts

@@ -1,3 +1,4 @@
+import type { RuntimeHost } from '../../runtime/host/types';
 export interface EmbeddedInngestServiceOptions {
     edition: 'cloud' | 'local';
     apiBaseUrl: string;
@@ -13,10 +14,32 @@ export interface EmbeddedInngestServiceOptions {
     signingKey?: string;
     binaryPath?: string;
     sqliteDir?: string;
+    /**
+     * Unix socket the API is bound to. When set, the spawned executor's callback
+     * cannot be addressed by the public base URL, so a private loopback bridge is
+     * derived instead of pointing the executor at an unreachable `http://localhost`.
+     */
+    socketPath?: string;
+    /**
+     * Gateway's internal marker secret. The bridge signs each forwarded callback
+     * with this secret and `originalClientLoopback: true`, which is the canonical
+     * evidence the dev callback authorizer trusts for an unsigned local executor.
+     */
+    gatewayAdminProxyAuthSecret?: string;
+    /** Runtime host used to bind/close the derived loopback listener. */
+    runtimeHost?: RuntimeHost;
 }
 export interface EmbeddedInngestRuntimeConfig {
     enabled: boolean;
     durableDelivery: boolean;
+    /**
+     * The executor protocol Xpod actually resolved and started. This is the
+     * authoritative answer to "is the callback signed?" and is independent of
+     * whether delivery is durable. Consumers (serve handler / SDK client) must
+     * read this instead of re-deriving `edition + configured mode`, so the
+     * spawned dev executor and a managed executor can never drift apart.
+     */
+    mode?: 'managed' | 'spawn';
     baseUrl?: string;
     eventKey?: string;
     signingKey?: string;
@@ -34,11 +57,68 @@ export interface EmbeddedInngestRuntimeConfig {
 export declare class EmbeddedInngestService {
     private readonly logger;
     private readonly options;
+    private readonly runtimeHost;
     private child?;
     private config?;
+    private callbackServer?;
+    private callbackEndpoint?;
+    private callbackBaseUrl?;
+    /**
+     * Increases every time the bridge is (re)started or closed. Async child
+     * events capture the value they were created under so a callback bridge that
+     * belongs to a later `start()` is never torn down by an earlier child's exit.
+     */
+    private callbackGeneration;
     constructor(options: EmbeddedInngestServiceOptions);
     start(): Promise<EmbeddedInngestRuntimeConfig>;
+    /**
+     * A spawned executor that dies or fails to start leaves no durable delivery.
+     *
+     * The failure is reported by invalidating the resolved config (so the next
+     * `start()` can retry rather than hand back the stale result) and closing the
+     * callback bridge this child owned. Only the current child invalidates:
+     * `stop()` clears `this.child` first, and `callbackGeneration` moves on every
+     * bridge start/close, so a replaced child's late event cannot race a newer
+     * one.
+     */
+    private invalidateDelivery;
+    /**
+     * Marks the resolved config as no longer delivering and drops the cache.
+     *
+     * `this.config` is the same object handed to callers and registered by the
+     * API container, so clearing the private reference alone would leave
+     * consumers reading `durableDelivery: true`. Mutate the object first, then
+     * drop the cache so the next `start()` re-resolves.
+     */
+    private invalidateResolvedConfig;
     stop(): Promise<void>;
+    /**
+     * Address the spawned executor must POST its callbacks to.
+     *
+     * With a Unix-socket API there is no TCP listener to name, so a private
+     * loopback bridge is derived. Managed and port transports keep the public
+     * base URL untouched.
+     */
+    private resolveFunctionEndpoint;
+    private startCallbackBridge;
+    /**
+     * Closes the owned bridge unless a newer child has already replaced it.
+     *
+     * `expectedGeneration` is the value captured when a child was spawned. A
+     * mismatch means a later `start()` owns the current bridge, so this close must
+     * not touch it.
+     */
+    private stopCallbackBridge;
+    /**
+     * Forward an executor callback to the API over its Unix socket.
+     *
+     * Only the Inngest callback path is proxied: this listener is a transport for
+     * one executor, not a second API surface. The Gateway marker is re-created
+     * (after stripping any inbound marker) so the API sees the canonical signed
+     * local-client evidence even though a Unix socket carries no peer address.
+     */
+    private forwardCallback;
+    private forwardCallbackHeaders;
     private resolveUsableBinaryPath;
     private isUsableBinary;
     private buildArguments;

package/dist/api/runs/EmbeddedInngestService.js

@@ -25,10 +25,30 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmbeddedInngestService = void 0;
 const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
 const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const global_logger_factory_1 = require("global-logger-factory");
 const runtime_1 = require("../../runtime");
+const port_finder_1 = require("../../runtime/port-finder");
+const socket_transport_1 = require("../../runtime/socket-transport");
+const GatewayAdminProxyAuth_1 = require("../../runtime/GatewayAdminProxyAuth");
+const NodeRuntimeHost_1 = require("../../runtime/host/node/NodeRuntimeHost");
+const readBoundedRequestBody_1 = require("../handlers/readBoundedRequestBody");
+const MatrixError_1 = require("../matrix/MatrixError");
+const HOP_BY_HOP_HEADERS = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'trailers',
+    'transfer-encoding',
+    'upgrade',
+]);
+const CALLBACK_BODY_LIMIT_BYTES = 25 * 1024 * 1024;
+const CALLBACK_BODY_LIMIT_MESSAGE = 'Inngest callback body exceeded the bridge limit';
 /**
  * Xpod-owned Inngest runtime process.
  *
@@ -41,7 +61,14 @@ const runtime_1 = require("../../runtime");
 class EmbeddedInngestService {
     constructor(options) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        /**
+         * Increases every time the bridge is (re)started or closed. Async child
+         * events capture the value they were created under so a callback bridge that
+         * belongs to a later `start()` is never torn down by an earlier child's exit.
+         */
+        this.callbackGeneration = 0;
         this.options = options;
+        this.runtimeHost = options.runtimeHost ?? NodeRuntimeHost_1.nodeRuntimeHost;
     }
     async start() {
         if (this.config) {
@@ -64,25 +91,41 @@ class EmbeddedInngestService {
         const host = this.options.host || '127.0.0.1';
         const port = this.options.port ?? (mode === 'spawn' ? await (0, runtime_1.getFreePort)(8288, host) : 8288);
         const baseUrl = this.options.baseUrl || (mode === 'spawn' ? `http://${host}:${port}` : 'http://xpod-inngest:8288');
-        const functionEndpoint = new URL(this.options.apiPath ?? '/api/inngest', this.options.apiBaseUrl).toString();
-        this.config = {
+        const apiPath = this.options.apiPath ?? '/api/inngest';
+        const config = {
             enabled: true,
             durableDelivery: false,
+            mode,
             baseUrl,
             eventKey,
             signingKey,
-            functionEndpoint,
         };
         if (mode === 'managed') {
-            this.config.durableDelivery = this.config.enabled;
-            this.logger.info(`Using managed embedded Inngest at ${baseUrl}, function endpoint ${functionEndpoint}`);
-            return this.config;
+            config.functionEndpoint = new URL(apiPath, this.options.apiBaseUrl).toString();
+            config.durableDelivery = config.enabled;
+            this.config = config;
+            this.logger.info(`Using managed embedded Inngest at ${baseUrl}, function endpoint ${config.functionEndpoint}`);
+            return config;
         }
         const binary = this.resolveUsableBinaryPath();
         if (!binary) {
+            config.functionEndpoint = new URL(apiPath, this.options.apiBaseUrl).toString();
+            this.config = config;
             this.logger.warn('Embedded Inngest binary not found; Xpod will still expose the function endpoint, but durable delivery is unavailable.');
-            return this.config;
+            return config;
+        }
+        // Resolve the callback endpoint before publishing `config`: a missing marker
+        // secret or a rejected bridge listen throws here, and this start must leave
+        // no cached enabled config behind (so the same instance can retry).
+        let functionEndpoint;
+        try {
+            functionEndpoint = await this.resolveFunctionEndpoint(apiPath);
         }
+        catch (error) {
+            await this.stopCallbackBridge().catch(() => undefined);
+            throw error;
+        }
+        config.functionEndpoint = functionEndpoint;
         const env = this.buildEnvironment({
             baseUrl,
             eventKey,
@@ -90,53 +133,271 @@ class EmbeddedInngestService {
             functionEndpoint,
         });
         const args = this.buildArguments(host, port, functionEndpoint);
-        this.child = (0, node_child_process_1.spawn)(binary, args, {
-            cwd: runtime_1.PACKAGE_ROOT,
-            env,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        this.child.stdout?.on('data', (chunk) => {
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(binary, args, {
+                cwd: runtime_1.PACKAGE_ROOT,
+                env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (error) {
+            await this.stopCallbackBridge().catch(() => undefined);
+            throw error;
+        }
+        this.config = config;
+        this.child = child;
+        const childGeneration = this.callbackGeneration;
+        child.stdout?.on('data', (chunk) => {
             this.logger.info(`[Inngest] ${String(chunk).trim()}`);
         });
-        this.child.stderr?.on('data', (chunk) => {
+        child.stderr?.on('data', (chunk) => {
             this.logger.warn(`[Inngest] ${String(chunk).trim()}`);
         });
-        this.child.once('exit', (code, signal) => {
+        child.once('exit', (code, signal) => {
             const message = `Embedded Inngest exited: code=${code ?? 'null'} signal=${signal ?? 'null'}`;
-            if (code && code !== 0) {
-                this.logger.error(message);
+            // Any exit of the current child means no executor remains: an executor
+            // that terminates cleanly still must not keep advertising durable
+            // delivery or an open callback bridge. Explicit stop() clears ownership
+            // first, so this path only fires for a live child.
+            if (code === 0 && signal === null) {
+                this.logger.info(message);
             }
             else {
-                this.logger.info(message);
+                this.logger.error(message);
             }
-            this.child = undefined;
+            this.invalidateDelivery('exited', child, childGeneration, message);
         });
-        this.child.once('error', (error) => {
-            this.logger.error(`Failed to start embedded Inngest: ${error}`);
-            this.child = undefined;
+        child.once('error', (error) => {
+            const message = `Failed to start embedded Inngest: ${error}`;
+            this.logger.error(message);
+            this.invalidateDelivery('failed to start', child, childGeneration, message);
         });
         this.logger.info(`Embedded Inngest starting at ${baseUrl}, function endpoint ${functionEndpoint}`);
-        this.config.durableDelivery = true;
-        return this.config;
+        config.durableDelivery = true;
+        return config;
     }
-    async stop() {
-        const child = this.child;
-        if (!child) {
+    /**
+     * A spawned executor that dies or fails to start leaves no durable delivery.
+     *
+     * The failure is reported by invalidating the resolved config (so the next
+     * `start()` can retry rather than hand back the stale result) and closing the
+     * callback bridge this child owned. Only the current child invalidates:
+     * `stop()` clears `this.child` first, and `callbackGeneration` moves on every
+     * bridge start/close, so a replaced child's late event cannot race a newer
+     * one.
+     */
+    invalidateDelivery(reason, child, childGeneration, message) {
+        if (this.child !== child) {
             return;
         }
         this.child = undefined;
-        await new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                child.kill('SIGKILL');
-                resolve();
-            }, 5_000);
-            timer.unref?.();
-            child.once('exit', () => {
-                clearTimeout(timer);
-                resolve();
+        this.invalidateResolvedConfig();
+        void this.stopCallbackBridge(childGeneration).catch((error) => {
+            this.logger.warn(`Failed to close Inngest callback bridge after executor ${reason}: ${error}`);
+        });
+        this.logger.warn(`Embedded Inngest durable delivery disabled: executor ${reason} (${message})`);
+    }
+    /**
+     * Marks the resolved config as no longer delivering and drops the cache.
+     *
+     * `this.config` is the same object handed to callers and registered by the
+     * API container, so clearing the private reference alone would leave
+     * consumers reading `durableDelivery: true`. Mutate the object first, then
+     * drop the cache so the next `start()` re-resolves.
+     */
+    invalidateResolvedConfig() {
+        if (this.config) {
+            this.config.durableDelivery = false;
+            this.config = undefined;
+        }
+    }
+    async stop() {
+        const child = this.child;
+        if (child) {
+            this.child = undefined;
+            await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    child.kill('SIGKILL');
+                    resolve();
+                }, 5_000);
+                timer.unref?.();
+                child.once('exit', () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+                child.kill('SIGTERM');
             });
-            child.kill('SIGTERM');
+        }
+        // Stopping the service ends durable delivery for any consumer holding the
+        // previously returned config, even though the explicit stop already
+        // disowned the child so its exit event is ignored.
+        this.invalidateResolvedConfig();
+        await this.stopCallbackBridge();
+    }
+    /**
+     * Address the spawned executor must POST its callbacks to.
+     *
+     * With a Unix-socket API there is no TCP listener to name, so a private
+     * loopback bridge is derived. Managed and port transports keep the public
+     * base URL untouched.
+     */
+    async resolveFunctionEndpoint(apiPath) {
+        // `resolveApiBaseUrl` collapses to `http://localhost/` under socket
+        // transport, which names no listener. A spawned executor cannot reach it,
+        // so a socket+spawn runtime without a derived bridge fails here instead of
+        // advertising an unreachable callback as durable.
+        if (!this.options.socketPath) {
+            return new URL(apiPath, this.options.apiBaseUrl).toString();
+        }
+        if (!this.options.gatewayAdminProxyAuthSecret) {
+            throw new Error('Socket Inngest callback bridge requires the Gateway marker secret (XPOD_GATEWAY_ADMIN_PROXY_AUTH_SECRET); '
+                + 'a spawned executor cannot reach the socket-only API without it');
+        }
+        await this.startCallbackBridge(this.options.socketPath);
+        return new URL(apiPath, `${this.callbackBaseUrl}/`).toString();
+    }
+    async startCallbackBridge(socketPath) {
+        const port = await (0, port_finder_1.getEphemeralLoopbackPort)();
+        const endpoint = this.runtimeHost.createListenEndpoint({ port, host: '127.0.0.1' });
+        const server = http.createServer((req, res) => {
+            void this.forwardCallback(socketPath, req, res);
         });
+        // Move to a new bridge generation before listening. A failed start must be
+        // cleaned by reference (listen never completed, so ownership was never
+        // recorded); a successful start records ownership below.
+        this.callbackGeneration += 1;
+        this.callbackServer = undefined;
+        this.callbackEndpoint = undefined;
+        this.callbackBaseUrl = undefined;
+        try {
+            await this.runtimeHost.listen(server, endpoint);
+        }
+        catch (error) {
+            // The listener may have bound before failing; close it by reference so no
+            // partial listener is ever left unowned.
+            server.closeAllConnections?.();
+            await this.runtimeHost.close(server, endpoint).catch(() => undefined);
+            throw error;
+        }
+        this.callbackServer = server;
+        this.callbackEndpoint = endpoint;
+        this.callbackBaseUrl = `http://127.0.0.1:${port}`;
+        this.logger.info(`Inngest callback bridge on ${this.callbackBaseUrl} -> unix://${socketPath}`);
+    }
+    /**
+     * Closes the owned bridge unless a newer child has already replaced it.
+     *
+     * `expectedGeneration` is the value captured when a child was spawned. A
+     * mismatch means a later `start()` owns the current bridge, so this close must
+     * not touch it.
+     */
+    async stopCallbackBridge(expectedGeneration) {
+        if (expectedGeneration !== undefined && expectedGeneration !== this.callbackGeneration) {
+            return;
+        }
+        const server = this.callbackServer;
+        const endpoint = this.callbackEndpoint;
+        this.callbackServer = undefined;
+        this.callbackEndpoint = undefined;
+        this.callbackBaseUrl = undefined;
+        this.callbackGeneration += 1;
+        if (!server) {
+            return;
+        }
+        try {
+            // HTTP clients keep the bridge connection alive; drop them so the close
+            // callback (which waits for idle connections) does not stall shutdown.
+            server.closeAllConnections?.();
+            await this.runtimeHost.close(server, endpoint);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to stop Inngest callback bridge: ${error}`);
+        }
+    }
+    /**
+     * Forward an executor callback to the API over its Unix socket.
+     *
+     * Only the Inngest callback path is proxied: this listener is a transport for
+     * one executor, not a second API surface. The Gateway marker is re-created
+     * (after stripping any inbound marker) so the API sees the canonical signed
+     * local-client evidence even though a Unix socket carries no peer address.
+     */
+    async forwardCallback(socketPath, req, res) {
+        const rawUrl = req.url ?? '/';
+        if (!isInngestCallbackPath(rawUrl)) {
+            res.statusCode = 404;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: 'Not Found' }));
+            return;
+        }
+        let chunks;
+        try {
+            chunks = await (0, readBoundedRequestBody_1.readBoundedRequestBody)(req, CALLBACK_BODY_LIMIT_BYTES, CALLBACK_BODY_LIMIT_MESSAGE);
+        }
+        catch (error) {
+            const status = error instanceof MatrixError_1.MatrixError ? error.status : 400;
+            res.statusCode = status;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Bad Request' }));
+            return;
+        }
+        try {
+            const body = chunks.length === 0 ? undefined : Buffer.concat(chunks);
+            const headers = this.forwardCallbackHeaders(req, body);
+            const response = await (0, socket_transport_1.requestViaSocket)({
+                protocol: 'http:',
+                socketPath,
+                path: rawUrl,
+                method: req.method ?? 'GET',
+                headers,
+                body,
+            });
+            res.statusCode = response.status;
+            response.headers.forEach((value, key) => {
+                if (!HOP_BY_HOP_HEADERS.has(key.toLowerCase())) {
+                    res.setHeader(key, value);
+                }
+            });
+            res.end(response.body);
+        }
+        catch (error) {
+            this.logger.warn(`Inngest callback bridge failed to reach the API socket: ${error}`);
+            if (!res.headersSent) {
+                res.statusCode = 502;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: 'Inngest callback bridge unavailable' }));
+            }
+            else {
+                res.end();
+            }
+        }
+    }
+    forwardCallbackHeaders(req, body) {
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (value === undefined) {
+                continue;
+            }
+            const lower = key.toLowerCase();
+            if (HOP_BY_HOP_HEADERS.has(lower) || isGatewayMarkerHeader(lower)) {
+                continue;
+            }
+            headers[lower] = Array.isArray(value) ? value.join(', ') : String(value);
+        }
+        Object.assign(headers, (0, GatewayAdminProxyAuth_1.createGatewayAdminProxyHeaders)({
+            secret: this.options.gatewayAdminProxyAuthSecret,
+            method: req.method,
+            url: req.url,
+            originalClientLoopback: true,
+        }));
+        if (body && body.byteLength > 0) {
+            headers['content-length'] = String(body.byteLength);
+        }
+        else {
+            delete headers['content-length'];
+        }
+        return headers;
     }
     resolveUsableBinaryPath() {
         const configured = this.options.binaryPath;
@@ -212,4 +473,17 @@ class EmbeddedInngestService {
     }
 }
 exports.EmbeddedInngestService = EmbeddedInngestService;
+function isInngestCallbackPath(rawUrl) {
+    let pathname;
+    try {
+        pathname = new URL(rawUrl, 'http://localhost').pathname;
+    }
+    catch {
+        pathname = rawUrl.split('?', 1)[0] ?? '/';
+    }
+    return pathname === '/api/inngest' || pathname.startsWith('/api/inngest/');
+}
+function isGatewayMarkerHeader(lowercaseHeader) {
+    return GatewayAdminProxyAuth_1.GATEWAY_ADMIN_PROXY_HEADERS.includes(lowercaseHeader);
+}
 //# sourceMappingURL=EmbeddedInngestService.js.map

package/dist/api/runs/InngestRunExecutionBackend.d.ts

@@ -161,7 +161,7 @@ export declare class InngestRunExecutionBackend implements RunExecutionBackend {
         readonly event: string;
     }], Omit<Omit<import("inngest").BaseContext<Inngest.Any>, never> & Record<never, never> & {
         logger: import("inngest").Logger;
-    }, "group" | "step" | "requestId" | "event" | "attempt" | "events" | "runId" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
+    }, "step" | "group" | "requestId" | "event" | "attempt" | "events" | "runId" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
         step: {
             sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
             waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {
@@ -342,7 +342,7 @@ export declare class InngestRunExecutionBackend implements RunExecutionBackend {
         readonly event: string;
     }], Omit<Omit<import("inngest").BaseContext<Inngest.Any>, never> & Record<never, never> & {
         logger: import("inngest").Logger;
-    }, "group" | "step" | "requestId" | "event" | "attempt" | "events" | "runId" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
+    }, "step" | "group" | "requestId" | "event" | "attempt" | "events" | "runId" | "defer" | "jobId" | "maxAttempts"> & import("inngest").FailureEventArgs<EventPayload<any>> & {
         step: {
             sendEvent: (idOrOptions: import("inngest").StepOptionsOrId, payload: import("inngest").SendEventPayload) => Promise<import("inngest/types").SendEventOutput<import("inngest").ClientOptionsFromInngest<Inngest<import("inngest").ClientOptions>>>>;
             waitForSignal: <TData>(idOrOptions: import("inngest").StepOptionsOrId, opts: {

package/dist/api/runs/InngestRunExecutionBackend.js

@@ -65,6 +65,10 @@ class InngestRunExecutionBackend {
     }
     async *start(input) {
         const queue = new AsyncPushQueue();
+        const onAbort = () => queue.close();
+        if (input.signal?.aborted)
+            return;
+        input.signal?.addEventListener('abort', onAbort, { once: true });
         this.pendingRuns.set(input.runId, { input, queue, started: false });
         const context = input.context;
         this.contextRecorder?.(context);
@@ -112,6 +116,7 @@ class InngestRunExecutionBackend {
             yield { type: 'error', message: this.formatError(error) };
         }
         finally {
+            input.signal?.removeEventListener('abort', onAbort);
             this.pendingRuns.delete(input.runId);
             queue.close();
         }