@hypequery/deployment 0.3.0 → 0.5.0

package/dist/data-plane.js

@@ -0,0 +1,209 @@
+import { createProtocolSchemaValueParser, ProtocolSchemaValueError, ProtocolValueError, validateProtocolDeploymentContract, } from '@hypequery/protocol';
+import { resolveDeploymentDataPlaneLimits, } from './data-plane-limits.js';
+export class DeploymentDataPlaneError extends Error {
+    code;
+    path;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'DeploymentDataPlaneError';
+        this.code = code;
+        this.path = options.path;
+    }
+}
+function dataPlaneError(code, message, cause, path) {
+    return new DeploymentDataPlaneError(code, message, { cause, path });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw dataPlaneError('HQ_DATA_PLANE_ABORTED', 'The data-plane request was aborted.', signal.reason);
+    }
+}
+function frozenRecord(entries) {
+    return Object.freeze(Object.assign(Object.create(null), entries));
+}
+function valueAtPath(input, path) {
+    let value = input;
+    for (const segment of path.split('.')) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)
+            || !Object.hasOwn(value, segment))
+            return undefined;
+        value = value[segment];
+    }
+    return value;
+}
+function sqlParameters(query, input, tenant) {
+    if (query.implementation.kind !== 'compiled-sql')
+        return Object.freeze({});
+    const values = Object.create(null);
+    for (const parameter of query.implementation.parameters) {
+        const value = parameter.source.kind === 'tenant'
+            ? tenant
+            : valueAtPath(input, parameter.source.path);
+        if (value === undefined) {
+            throw dataPlaneError('HQ_DATA_PLANE_INPUT_INVALID', 'A required compiled SQL binding is missing.', undefined, parameter.source.kind === 'input' ? `$.${parameter.source.path}` : '$.tenant');
+        }
+        values[parameter.name] = value;
+    }
+    return frozenRecord(values);
+}
+function routeTable(deployment, limits) {
+    const routes = new Map();
+    for (const query of deployment.queries) {
+        routes.set(`${query.endpoint.method}\0${query.endpoint.path}`, Object.freeze({
+            query,
+            input: createProtocolSchemaValueParser(query.input, { limits }),
+            output: createProtocolSchemaValueParser(query.output, { limits }),
+        }));
+    }
+    return routes;
+}
+function missing(values, actual) {
+    const available = new Set(actual ?? []);
+    return values.filter(value => !available.has(value));
+}
+export function createDeploymentDataPlane(options) {
+    let deployment;
+    try {
+        deployment = validateProtocolDeploymentContract(options.deployment);
+    }
+    catch (error) {
+        throw dataPlaneError('HQ_DATA_PLANE_CONFIGURATION', 'The deployment data plane requires a valid deployment contract.', error);
+    }
+    const limits = resolveDeploymentDataPlaneLimits(options.limits);
+    const routes = routeTable(deployment, limits);
+    const paths = new Set(deployment.queries.map(query => query.endpoint.path));
+    async function execute(request, json) {
+        throwIfAborted(request.signal);
+        const route = routes.get(`${request.method}\0${request.path}`);
+        if (!route) {
+            if (paths.has(request.path)) {
+                throw dataPlaneError('HQ_DATA_PLANE_METHOD_NOT_ALLOWED', 'The deployment route does not support this method.');
+            }
+            throw dataPlaneError('HQ_DATA_PLANE_ROUTE_NOT_FOUND', 'The deployment route was not found.');
+        }
+        const { query } = route;
+        let principal = null;
+        if (query.endpoint.access.kind === 'authenticated' && !options.authenticate) {
+            throw dataPlaneError('HQ_DATA_PLANE_CONFIGURATION', 'An authenticator is required for this deployment route.');
+        }
+        if (options.authenticate
+            && (query.endpoint.access.kind === 'authenticated' || request.credentials !== undefined)) {
+            try {
+                principal = await options.authenticate({ credentials: request.credentials, request, query });
+            }
+            catch (error) {
+                throw dataPlaneError('HQ_DATA_PLANE_UNAUTHENTICATED', 'Authentication failed.', error);
+            }
+        }
+        throwIfAborted(request.signal);
+        if (query.endpoint.access.kind === 'authenticated') {
+            if (!principal) {
+                throw dataPlaneError('HQ_DATA_PLANE_UNAUTHENTICATED', 'Authentication is required.');
+            }
+            if (missing(query.endpoint.access.roles, principal.roles).length > 0
+                || missing(query.endpoint.access.scopes, principal.scopes).length > 0) {
+                throw dataPlaneError('HQ_DATA_PLANE_FORBIDDEN', 'The principal lacks required access.');
+            }
+        }
+        let tenant;
+        if (query.endpoint.tenant.kind !== 'not-required') {
+            if (!options.resolveTenant) {
+                if (query.endpoint.tenant.kind === 'required') {
+                    throw dataPlaneError('HQ_DATA_PLANE_CONFIGURATION', 'A tenant resolver is required for this deployment route.');
+                }
+            }
+            else {
+                try {
+                    tenant = await options.resolveTenant({ principal, request, query });
+                }
+                catch (error) {
+                    throw dataPlaneError('HQ_DATA_PLANE_FORBIDDEN', 'Tenant resolution failed.', error);
+                }
+            }
+            if (query.endpoint.tenant.kind === 'required' && (tenant === undefined || tenant === null)) {
+                throw dataPlaneError('HQ_DATA_PLANE_TENANT_REQUIRED', 'Tenant context is required.');
+            }
+        }
+        throwIfAborted(request.signal);
+        let input;
+        try {
+            if (json && request.input !== undefined) {
+                if (typeof route.input.parseJson !== 'function')
+                    throw dataPlaneError('HQ_DATA_PLANE_CONFIGURATION', 'The route input parser does not support JSON request bodies.');
+                input = route.input.parseJson(request.input);
+            }
+            else {
+                input = route.input.parse(request.input);
+            }
+        }
+        catch (error) {
+            if (error instanceof ProtocolSchemaValueError || error instanceof ProtocolValueError) {
+                throw dataPlaneError('HQ_DATA_PLANE_INPUT_INVALID', 'The request input does not match the deployment schema.', error, error.path);
+            }
+            throw error;
+        }
+        const common = { query, input, principal, tenant, request, signal: request.signal };
+        let output;
+        try {
+            switch (query.implementation.kind) {
+                case 'semantic-plan':
+                    if (!options.executeSemanticPlan)
+                        throw dataPlaneError('HQ_DATA_PLANE_EXECUTOR_UNAVAILABLE', 'No semantic-plan executor is configured.');
+                    output = await options.executeSemanticPlan({
+                        ...common,
+                        implementation: query.implementation,
+                        deployment,
+                    });
+                    break;
+                case 'compiled-sql':
+                    if (!options.executeCompiledSql)
+                        throw dataPlaneError('HQ_DATA_PLANE_EXECUTOR_UNAVAILABLE', 'No compiled SQL executor is configured.');
+                    output = await options.executeCompiledSql({
+                        ...common,
+                        implementation: query.implementation,
+                        parameters: sqlParameters(query, input, tenant),
+                    });
+                    break;
+                case 'runtime-reference':
+                    if (!options.executeRuntimeReference)
+                        throw dataPlaneError('HQ_DATA_PLANE_EXECUTOR_UNAVAILABLE', 'No runtime-reference executor is configured.');
+                    output = await options.executeRuntimeReference({
+                        ...common,
+                        implementation: query.implementation,
+                    });
+                    break;
+            }
+        }
+        catch (error) {
+            if (error instanceof DeploymentDataPlaneError)
+                throw error;
+            if (request.signal?.aborted) {
+                throw dataPlaneError('HQ_DATA_PLANE_ABORTED', 'The data-plane request was aborted.', error);
+            }
+            throw dataPlaneError('HQ_DATA_PLANE_EXECUTION_FAILED', 'Deployment query execution failed.', error);
+        }
+        try {
+            output = route.output.parse(output);
+        }
+        catch (error) {
+            if (error instanceof ProtocolSchemaValueError) {
+                throw dataPlaneError('HQ_DATA_PLANE_OUTPUT_INVALID', 'The query output does not match the deployment schema.', error, error.path);
+            }
+            throw error;
+        }
+        const publicCacheTtlMs = query.endpoint.access.kind === 'public'
+            && query.endpoint.tenant.kind === 'not-required'
+            && principal === null
+            ? query.endpoint.cacheTtlMs
+            : undefined;
+        return Object.freeze({
+            query: query.name,
+            output,
+            ...(publicCacheTtlMs === undefined ? {} : { cacheTtlMs: publicCacheTtlMs }),
+        });
+    }
+    return Object.freeze({
+        execute: (request) => execute(request, false),
+        executeJson: (request) => execute(request, true),
+    });
+}

package/dist/filesystem-host.d.ts

@@ -0,0 +1,51 @@
+import type { ProtocolDeploymentReleaseTarget } from '@hypequery/protocol';
+import { type DeploymentActivationRegistry } from './activation.js';
+import { type DeploymentControlPlane, type DeploymentControlPlaneAuthorizer } from './control-plane.js';
+import type { DeploymentControlPlaneLimits } from './control-plane-limits.js';
+import { type FileSystemDeploymentSubmissionStore } from './filesystem-store.js';
+import { type DeploymentHost, type DeploymentHostDataPlaneConfiguration, type DeploymentHostDataPlaneInput } from './host.js';
+import type { DeploymentIntakeLimits } from './limits.js';
+import { type NodeDeploymentRuntimeFactoryOptions } from './node-runtime-factory.js';
+import { type DeploymentRuntimeMaterializer } from './runtime-materialization.js';
+import { type DeploymentRuntimeFactory, type DeploymentRuntimeSupervisor } from './runtime-supervisor.js';
+import type { DeploymentAuthenticator, DeploymentAuthorizer, DeploymentIntake } from './types.js';
+export interface FileSystemDeploymentHostOptions<SubmissionPrincipal, ControlPrincipal> {
+    readonly directory: string;
+    readonly targets: readonly ProtocolDeploymentReleaseTarget[];
+    readonly intake: {
+        readonly authenticator: DeploymentAuthenticator<SubmissionPrincipal>;
+        readonly authorizer: DeploymentAuthorizer<SubmissionPrincipal>;
+        readonly limits?: Partial<DeploymentIntakeLimits>;
+        readonly temporaryDirectory?: string;
+    };
+    readonly controlPlane: {
+        readonly authenticator: DeploymentAuthenticator<ControlPrincipal>;
+        readonly authorizer: DeploymentControlPlaneAuthorizer<ControlPrincipal>;
+        readonly limits?: Partial<DeploymentControlPlaneLimits>;
+    };
+    readonly configureDataPlane: (input: DeploymentHostDataPlaneInput) => DeploymentHostDataPlaneConfiguration | Promise<DeploymentHostDataPlaneConfiguration>;
+    /** Defaults to the reference Node worker runtime factory. */
+    readonly runtimeFactory?: DeploymentRuntimeFactory;
+    readonly nodeRuntime?: NodeDeploymentRuntimeFactoryOptions;
+    readonly activationClock?: () => Date;
+    readonly maxMaterializationAttempts?: number;
+    readonly drainTimeoutMs?: number;
+    readonly maxReconcileAttempts?: number;
+    readonly maxHostStabilityAttempts?: number;
+    readonly onBackgroundError?: (error: unknown) => void;
+}
+export interface FileSystemDeploymentHost<SubmissionPrincipal> {
+    readonly store: FileSystemDeploymentSubmissionStore<SubmissionPrincipal>;
+    readonly activations: DeploymentActivationRegistry;
+    readonly intake: DeploymentIntake;
+    readonly controlPlane: DeploymentControlPlane;
+    readonly materializer: DeploymentRuntimeMaterializer;
+    readonly supervisor: DeploymentRuntimeSupervisor;
+    readonly host: DeploymentHost;
+    start(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createFileSystemDeploymentHost<SubmissionPrincipal, ControlPrincipal>(options: FileSystemDeploymentHostOptions<SubmissionPrincipal, ControlPrincipal>): FileSystemDeploymentHost<SubmissionPrincipal>;
+//# sourceMappingURL=filesystem-host.d.ts.map

package/dist/filesystem-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem-host.d.ts","sourceRoot":"","sources":["../src/filesystem-host.ts"],"names":[],"mappings":"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"}

package/dist/filesystem-host.js

@@ -0,0 +1,73 @@
+import { createFileSystemDeploymentActivationRegistry, } from './activation.js';
+import { createDeploymentControlPlane, } from './control-plane.js';
+import { createFileSystemDeploymentSubmissionStore, } from './filesystem-store.js';
+import { createDeploymentHost, } from './host.js';
+import { createDeploymentIntake } from './intake.js';
+import { createNodeWorkerDeploymentRuntimeFactory, } from './node-runtime-factory.js';
+import { createDeploymentRuntimeMaterializer, } from './runtime-materialization.js';
+import { createDeploymentRuntimeSupervisor, } from './runtime-supervisor.js';
+export function createFileSystemDeploymentHost(options) {
+    if (options.runtimeFactory !== undefined && options.nodeRuntime !== undefined) {
+        throw new TypeError('runtimeFactory and nodeRuntime cannot both be configured.');
+    }
+    const targets = Object.freeze([...options.targets]);
+    const store = createFileSystemDeploymentSubmissionStore({
+        directory: options.directory,
+    });
+    const activations = createFileSystemDeploymentActivationRegistry({
+        directory: options.directory,
+        releases: store,
+        clock: options.activationClock,
+    });
+    const intake = createDeploymentIntake({
+        ...options.intake,
+        store,
+    });
+    const materializer = createDeploymentRuntimeMaterializer({
+        activations,
+        releases: store,
+        maxStabilityAttempts: options.maxMaterializationAttempts,
+    });
+    const runtimeFactory = options.runtimeFactory
+        ?? createNodeWorkerDeploymentRuntimeFactory(options.nodeRuntime);
+    const supervisor = createDeploymentRuntimeSupervisor({
+        materializer,
+        factory: runtimeFactory,
+        drainTimeoutMs: options.drainTimeoutMs,
+        maxReconcileAttempts: options.maxReconcileAttempts,
+        onBackgroundError: options.onBackgroundError,
+    });
+    const host = createDeploymentHost({
+        supervisor,
+        configureDataPlane: options.configureDataPlane,
+        maxStabilityAttempts: options.maxHostStabilityAttempts,
+        onBackgroundError: options.onBackgroundError,
+    });
+    const controlPlane = createDeploymentControlPlane({
+        intake,
+        activations,
+        ...options.controlPlane,
+        onActivation: activation => host.scheduleReconcile(activation.target),
+        onBackgroundError: options.onBackgroundError,
+    });
+    let startPromise;
+    const result = {
+        store,
+        activations,
+        intake,
+        controlPlane,
+        materializer,
+        supervisor,
+        host,
+        start(startOptions = {}) {
+            const pending = startPromise ??= host.start(targets, startOptions).then(() => undefined);
+            void pending.catch(() => {
+                if (startPromise === pending)
+                    startPromise = undefined;
+            });
+            return pending;
+        },
+        close: () => host.close(),
+    };
+    return Object.freeze(result);
+}

package/dist/host.d.ts

@@ -0,0 +1,40 @@
+import { type ProtocolDeploymentContract, type ProtocolDeploymentReleaseTarget } from '@hypequery/protocol';
+import { type DeploymentDataPlane, type DeploymentDataPlaneOptions, type DeploymentDataPlaneRequest, type DeploymentDataPlaneResult, type DeploymentRuntimeReferenceExecutionInput } from './data-plane.js';
+import type { DeploymentRuntimeReconcileResult, DeploymentRuntimeStatus, DeploymentRuntimeSupervisor } from './runtime-supervisor.js';
+export type DeploymentHostErrorCode = 'HQ_DEPLOYMENT_HOST_CONFIGURATION' | 'HQ_DEPLOYMENT_HOST_CLOSED' | 'HQ_DEPLOYMENT_HOST_NOT_READY' | 'HQ_DEPLOYMENT_HOST_RECONCILE_FAILED' | 'HQ_DEPLOYMENT_HOST_RECONCILE_UNSTABLE';
+export declare class DeploymentHostError extends Error {
+    readonly code: DeploymentHostErrorCode;
+    constructor(code: DeploymentHostErrorCode, message: string, options?: {
+        readonly cause?: unknown;
+    });
+}
+export interface DeploymentHostDataPlaneInput {
+    readonly target: ProtocolDeploymentReleaseTarget;
+    readonly status: DeploymentRuntimeStatus;
+    readonly deployment: ProtocolDeploymentContract;
+}
+export type DeploymentHostDataPlaneConfiguration = Omit<DeploymentDataPlaneOptions, 'deployment' | 'executeRuntimeReference'> & {
+    readonly runtimeArgument: (input: DeploymentRuntimeReferenceExecutionInput) => unknown;
+};
+export interface DeploymentHostOptions {
+    readonly supervisor: DeploymentRuntimeSupervisor;
+    readonly configureDataPlane: (input: DeploymentHostDataPlaneInput) => DeploymentHostDataPlaneConfiguration | Promise<DeploymentHostDataPlaneConfiguration>;
+    /** Generation-stability attempts from 1 through 16. */
+    readonly maxStabilityAttempts?: number;
+    readonly onBackgroundError?: (error: unknown) => void;
+}
+export interface DeploymentHost {
+    start(targets: readonly ProtocolDeploymentReleaseTarget[], options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<readonly DeploymentRuntimeReconcileResult[]>;
+    reconcile(target: ProtocolDeploymentReleaseTarget, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<DeploymentRuntimeReconcileResult>;
+    scheduleReconcile(target: ProtocolDeploymentReleaseTarget): void;
+    execute(target: ProtocolDeploymentReleaseTarget, request: DeploymentDataPlaneRequest): Promise<DeploymentDataPlaneResult>;
+    dataPlane(target: ProtocolDeploymentReleaseTarget): DeploymentDataPlane;
+    status(target: ProtocolDeploymentReleaseTarget): DeploymentRuntimeStatus | undefined;
+    close(): Promise<void>;
+}
+export declare function createDeploymentHost(options: DeploymentHostOptions): DeploymentHost;
+//# sourceMappingURL=host.d.ts.map

package/dist/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,+BAA+B,EACrC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,wCAAwC,EAC9C,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAEV,gCAAgC,EAChC,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,yBAAyB,CAAC;AAKjC,MAAM,MAAM,uBAAuB,GAC/B,kCAAkC,GAClC,2BAA2B,GAC3B,8BAA8B,GAC9B,qCAAqC,GACrC,uCAAuC,CAAC;AAE5C,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAC;gBAGrC,IAAI,EAAE,uBAAuB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO;CAM7C;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,MAAM,EAAE,+BAA+B,CAAC;IACjD,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,0BAA0B,CAAC;CACjD;AAED,MAAM,MAAM,oCAAoC,GAAG,IAAI,CACrD,0BAA0B,EAC1B,YAAY,GAAG,yBAAyB,CACzC,GAAG;IACF,QAAQ,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,wCAAwC,KAAK,OAAO,CAAC;CACxF,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,2BAA2B,CAAC;IACjD,QAAQ,CAAC,kBAAkB,EAAE,CAC3B,KAAK,EAAE,4BAA4B,KAChC,oCAAoC,GAAG,OAAO,CAAC,oCAAoC,CAAC,CAAC;IAC1F,uDAAuD;IACvD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CACH,OAAO,EAAE,SAAS,+BAA+B,EAAE,EACnD,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,SAAS,gCAAgC,EAAE,CAAC,CAAC;IACxD,SAAS,CACP,MAAM,EAAE,+BAA+B,EACvC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1C,OAAO,CAAC,gCAAgC,CAAC,CAAC;IAC7C,iBAAiB,CAAC,MAAM,EAAE,+BAA+B,GAAG,IAAI,CAAC;IACjE,OAAO,CACL,MAAM,EAAE,+BAA+B,EACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,yBAAyB,CAAC,CAAC;IACtC,SAAS,CAAC,MAAM,EAAE,+BAA+B,GAAG,mBAAmB,CAAC;IACxE,MAAM,CAAC,MAAM,EAAE,+BAA+B,GAAG,uBAAuB,GAAG,SAAS,CAAC;IACrF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAiDD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAmLnF"}

package/dist/host.js

@@ -0,0 +1,183 @@
+import { validateProtocolDeploymentReleaseTarget, } from '@hypequery/protocol';
+import { createDeploymentDataPlane, } from './data-plane.js';
+import { createDeploymentRuntimeSupervisorExecutor } from './data-plane-runtime.js';
+const DEFAULT_STABILITY_ATTEMPTS = 4;
+const MAX_STABILITY_ATTEMPTS = 16;
+export class DeploymentHostError extends Error {
+    code;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'DeploymentHostError';
+        this.code = code;
+    }
+}
+function hostError(code, message, cause) {
+    return new DeploymentHostError(code, message, { cause });
+}
+function targetKey(target) {
+    return JSON.stringify([target.project, target.environment]);
+}
+function target(input) {
+    try {
+        return validateProtocolDeploymentReleaseTarget(input);
+    }
+    catch (error) {
+        throw hostError('HQ_DEPLOYMENT_HOST_CONFIGURATION', 'The deployment host target is invalid.', error);
+    }
+}
+function stabilityAttempts(input) {
+    const value = input ?? DEFAULT_STABILITY_ATTEMPTS;
+    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_STABILITY_ATTEMPTS) {
+        throw hostError('HQ_DEPLOYMENT_HOST_CONFIGURATION', `maxStabilityAttempts must be between 1 and ${MAX_STABILITY_ATTEMPTS}.`);
+    }
+    return value;
+}
+function sameGeneration(left, right) {
+    return left?.status.activationRevision === right?.status.activationRevision;
+}
+export function createDeploymentHost(options) {
+    if (!options.supervisor || typeof options.configureDataPlane !== 'function') {
+        throw hostError('HQ_DEPLOYMENT_HOST_CONFIGURATION', 'A runtime supervisor and data-plane configurator are required.');
+    }
+    const maximumAttempts = stabilityAttempts(options.maxStabilityAttempts);
+    const active = new Map();
+    const updates = new Map();
+    const background = new Set();
+    let closed = false;
+    let closePromise;
+    function ensureOpen() {
+        if (closed)
+            throw hostError('HQ_DEPLOYMENT_HOST_CLOSED', 'The deployment host is closed.');
+    }
+    function serialize(key, operation) {
+        const previous = updates.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        const tracked = current.finally(() => {
+            if (updates.get(key) === tracked)
+                updates.delete(key);
+        });
+        updates.set(key, tracked);
+        return tracked;
+    }
+    async function install(desiredTarget, signal) {
+        for (let attempt = 0; attempt < maximumAttempts; attempt += 1) {
+            ensureOpen();
+            const result = await options.supervisor.reconcile(desiredTarget, { signal });
+            ensureOpen();
+            if (result.status === 'deactivated' || result.status === 'no-active-release') {
+                active.delete(targetKey(desiredTarget));
+                return result;
+            }
+            const generation = options.supervisor.generation(desiredTarget);
+            if (!generation
+                || generation.status.activationRevision !== result.runtime.activationRevision) {
+                continue;
+            }
+            let configuration;
+            try {
+                configuration = await options.configureDataPlane(Object.freeze({
+                    target: desiredTarget,
+                    status: generation.status,
+                    deployment: generation.deployment,
+                }));
+            }
+            catch (error) {
+                throw hostError('HQ_DEPLOYMENT_HOST_RECONCILE_FAILED', 'The active deployment data plane could not be configured.', error);
+            }
+            ensureOpen();
+            let dataPlane;
+            try {
+                dataPlane = createDeploymentDataPlane({
+                    ...configuration,
+                    deployment: generation.deployment,
+                    executeRuntimeReference: createDeploymentRuntimeSupervisorExecutor({
+                        supervisor: options.supervisor,
+                        target: desiredTarget,
+                        activationRevision: generation.status.activationRevision,
+                        argument: configuration.runtimeArgument,
+                    }),
+                });
+            }
+            catch (error) {
+                throw hostError('HQ_DEPLOYMENT_HOST_RECONCILE_FAILED', 'The active deployment data plane could not be constructed.', error);
+            }
+            const confirmed = options.supervisor.generation(desiredTarget);
+            if (!sameGeneration(generation, confirmed))
+                continue;
+            active.set(targetKey(desiredTarget), Object.freeze({ generation, dataPlane }));
+            return result;
+        }
+        throw hostError('HQ_DEPLOYMENT_HOST_RECONCILE_UNSTABLE', 'The active deployment generation changed repeatedly during host reconciliation.');
+    }
+    const host = {
+        async start(targets, startOptions = {}) {
+            ensureOpen();
+            const validated = targets.map(target);
+            const keys = validated.map(targetKey);
+            if (new Set(keys).size !== keys.length) {
+                throw hostError('HQ_DEPLOYMENT_HOST_CONFIGURATION', 'Deployment host startup targets must be unique.');
+            }
+            return Object.freeze(await Promise.all(validated.map(candidate => (host.reconcile(candidate, startOptions)))));
+        },
+        reconcile(input, reconcileOptions = {}) {
+            ensureOpen();
+            const desiredTarget = target(input);
+            return serialize(targetKey(desiredTarget), () => install(desiredTarget, reconcileOptions.signal));
+        },
+        scheduleReconcile(input) {
+            ensureOpen();
+            const operation = host.reconcile(input).then(() => undefined).catch(error => {
+                try {
+                    options.onBackgroundError?.(error);
+                }
+                catch {
+                    // A diagnostic callback cannot make reconciliation an unhandled rejection.
+                }
+            });
+            background.add(operation);
+            void operation.finally(() => background.delete(operation)).catch(() => undefined);
+        },
+        async execute(input, request) {
+            ensureOpen();
+            const desiredTarget = target(input);
+            const hosted = active.get(targetKey(desiredTarget));
+            if (!hosted) {
+                throw hostError('HQ_DEPLOYMENT_HOST_NOT_READY', 'No deployment data plane is ready for target.');
+            }
+            return await hosted.dataPlane.execute(request);
+        },
+        dataPlane(input) {
+            ensureOpen();
+            const desiredTarget = target(input);
+            return Object.freeze({
+                execute: (request) => host.execute(desiredTarget, request),
+                executeJson: (request) => {
+                    ensureOpen();
+                    const hosted = active.get(targetKey(desiredTarget));
+                    if (!hosted) {
+                        throw hostError('HQ_DEPLOYMENT_HOST_NOT_READY', 'No deployment data plane is ready for target.');
+                    }
+                    return hosted.dataPlane.executeJson(request);
+                },
+            });
+        },
+        status(input) {
+            ensureOpen();
+            const desiredTarget = target(input);
+            return active.get(targetKey(desiredTarget))?.generation.status;
+        },
+        close() {
+            if (closePromise)
+                return closePromise;
+            closed = true;
+            closePromise = (async () => {
+                await Promise.allSettled([...updates.values()]);
+                await Promise.allSettled([...background]);
+                active.clear();
+                await options.supervisor.close();
+            })();
+            return closePromise;
+        },
+    };
+    return Object.freeze(host);
+}

package/dist/index.d.ts

@@ -20,6 +20,18 @@ export type { NodeDeploymentRuntimeErrorCode, NodeDeploymentRuntimeFactoryOption
 export { createDeploymentRuntimeMaterializer, DeploymentRuntimeMaterializationError, } from './runtime-materialization.js';
 export type { DeploymentRuntimeArtifactSnapshot, DeploymentRuntimeMaterializationErrorCode, DeploymentRuntimeMaterializer, DeploymentRuntimeMaterializerOptions, DeploymentRuntimeQueryBinding, DeploymentRuntimeRelease, DeploymentRuntimeReleaseReader, DeploymentRuntimeSnapshot, } from './runtime-materialization.js';
 export { createDeploymentRuntimeSupervisor, DeploymentRuntimeSupervisorError, } from './runtime-supervisor.js';
-export type { DeploymentRuntimeFactory, DeploymentRuntimeInstance, DeploymentRuntimeInstanceInvocation, DeploymentRuntimeInvocation, DeploymentRuntimeReconcileResult, DeploymentRuntimeStatus, DeploymentRuntimeSupervisor, DeploymentRuntimeSupervisorErrorCode, DeploymentRuntimeSupervisorOptions, } from './runtime-supervisor.js';
+export type { DeploymentRuntimeFactory, DeploymentRuntimeGeneration, DeploymentRuntimeInstance, DeploymentRuntimeInstanceInvocation, DeploymentRuntimeInvocation, DeploymentRuntimeReconcileResult, DeploymentRuntimeStatus, DeploymentRuntimeSupervisor, DeploymentRuntimeSupervisorErrorCode, DeploymentRuntimeSupervisorOptions, } from './runtime-supervisor.js';
 export type { DeploymentAuthenticationInput, DeploymentAuthenticator, DeploymentAuthorizationInput, DeploymentAuthorizer, DeploymentIntake, DeploymentIntakeOptions, DeploymentIntakeRequest, DeploymentIntakeResponse, DeploymentSubmissionResponse, DeploymentSubmissionStore, VerifiedDeploymentSubmission, } from './types.js';
+export { createDeploymentDataPlane, DeploymentDataPlaneError, } from './data-plane.js';
+export type { DeploymentCompiledSqlExecutionInput, DeploymentDataPlane, DeploymentDataPlaneAuthenticationInput, DeploymentDataPlaneErrorCode, DeploymentDataPlaneExecutionInput, DeploymentDataPlaneJsonRequest, DeploymentDataPlaneOptions, DeploymentDataPlanePrincipal, DeploymentDataPlaneRequest, DeploymentDataPlaneResult, DeploymentDataPlaneTenantInput, DeploymentRuntimeReferenceExecutionInput, DeploymentSemanticPlanExecutionInput, } from './data-plane.js';
+export { DEFAULT_DEPLOYMENT_DATA_PLANE_LIMITS, resolveDeploymentDataPlaneLimits, } from './data-plane-limits.js';
+export type { DeploymentDataPlaneLimits } from './data-plane-limits.js';
+export { createDeploymentRuntimeSupervisorExecutor } from './data-plane-runtime.js';
+export type { DeploymentRuntimeSupervisorExecutorOptions } from './data-plane-runtime.js';
+export { createDeploymentDataPlaneFetchHandler, createDeploymentDataPlaneNodeHandler, } from './data-plane-adapters.js';
+export type { DeploymentDataPlaneAdapterOptions, DeploymentDataPlaneAdapterRequest, DeploymentDataPlaneFetchHandler, DeploymentDataPlaneNodeHandler, } from './data-plane-adapters.js';
+export { createDeploymentHost, DeploymentHostError, } from './host.js';
+export { createFileSystemDeploymentHost } from './filesystem-host.js';
+export type { FileSystemDeploymentHost, FileSystemDeploymentHostOptions, } from './filesystem-host.js';
+export type { DeploymentHost, DeploymentHostDataPlaneConfiguration, DeploymentHostDataPlaneInput, DeploymentHostErrorCode, DeploymentHostOptions, } from './host.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4CAA4C,EAC5C,yBAAyB,EACzB,kCAAkC,GACnC,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,6BAA6B,EAC7B,+BAA+B,EAC/B,gCAAgC,EAChC,4BAA4B,EAC5B,2BAA2B,EAC3B,0BAA0B,EAC1B,2BAA2B,EAC3B,0BAA0B,EAC1B,uBAAuB,EACvB,6CAA6C,GAC9C,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EACL,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EACL,yCAAyC,EACzC,8BAA8B,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,kCAAkC,EAClC,mCAAmC,EACnC,0CAA0C,EAC1C,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,wCAAwC,EACxC,uCAAuC,GACxC,MAAM,6BAA6B,CAAC;AACrC,YAAY,EACV,kCAAkC,EAClC,iCAAiC,GAClC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,sBAAsB,EACtB,4BAA4B,EAC5B,wCAAwC,EACxC,gCAAgC,EAChC,+BAA+B,EAC/B,6BAA6B,EAC7B,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uCAAuC,EACvC,mCAAmC,GACpC,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EACL,gCAAgC,EAChC,6BAA6B,GAC9B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EACL,wCAAwC,EACxC,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,mCAAmC,EACnC,qCAAqC,GACtC,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,iCAAiC,EACjC,yCAAyC,EACzC,6BAA6B,EAC7B,oCAAoC,EACpC,6BAA6B,EAC7B,wBAAwB,EACxB,8BAA8B,EAC9B,yBAAyB,GAC1B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,iCAAiC,EACjC,gCAAgC,GACjC,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,mCAAmC,EACnC,2BAA2B,EAC3B,gCAAgC,EAChC,uBAAuB,EACvB,2BAA2B,EAC3B,oCAAoC,EACpC,kCAAkC,GACnC,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,6BAA6B,EAC7B,uBAAuB,EACvB,4BAA4B,EAC5B,oBAAoB,EACpB,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,GAC7B,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -10,3 +10,9 @@ export { DEFAULT_DEPLOYMENT_INTAKE_LIMITS, resolveDeploymentIntakeLimits, } from
 export { createNodeWorkerDeploymentRuntimeFactory, NodeDeploymentRuntimeError, } from './node-runtime-factory.js';
 export { createDeploymentRuntimeMaterializer, DeploymentRuntimeMaterializationError, } from './runtime-materialization.js';
 export { createDeploymentRuntimeSupervisor, DeploymentRuntimeSupervisorError, } from './runtime-supervisor.js';
+export { createDeploymentDataPlane, DeploymentDataPlaneError, } from './data-plane.js';
+export { DEFAULT_DEPLOYMENT_DATA_PLANE_LIMITS, resolveDeploymentDataPlaneLimits, } from './data-plane-limits.js';
+export { createDeploymentRuntimeSupervisorExecutor } from './data-plane-runtime.js';
+export { createDeploymentDataPlaneFetchHandler, createDeploymentDataPlaneNodeHandler, } from './data-plane-adapters.js';
+export { createDeploymentHost, DeploymentHostError, } from './host.js';
+export { createFileSystemDeploymentHost } from './filesystem-host.js';

package/dist/runtime-supervisor.d.ts

@@ -1,4 +1,4 @@
-import type { ProtocolDeploymentReleaseTarget } from '@hypequery/protocol';
+import type { ProtocolDeploymentContract, ProtocolDeploymentReleaseTarget } from '@hypequery/protocol';
 import type { DeploymentRuntimeMaterializer, DeploymentRuntimeQueryBinding, DeploymentRuntimeSnapshot } from './runtime-materialization.js';
 export type DeploymentRuntimeSupervisorErrorCode = 'HQ_RUNTIME_SUPERVISOR_CONFIGURATION' | 'HQ_RUNTIME_SUPERVISOR_CLOSED' | 'HQ_RUNTIME_NOT_READY' | 'HQ_RUNTIME_QUERY_NOT_FOUND' | 'HQ_RUNTIME_QUERY_NOT_EXECUTABLE' | 'HQ_RUNTIME_START_FAILED' | 'HQ_RUNTIME_HEALTH_FAILED' | 'HQ_RUNTIME_INVOCATION_FAILED' | 'HQ_RUNTIME_RECONCILE_UNSTABLE' | 'HQ_RUNTIME_ABORTED';
 export declare class DeploymentRuntimeSupervisorError extends Error {
@@ -27,6 +27,8 @@ export interface DeploymentRuntimeFactory {
 }
 export interface DeploymentRuntimeInvocation {
     readonly target: ProtocolDeploymentReleaseTarget;
+    /** Reject the invocation unless this exact activation generation is active. */
+    readonly activationRevision?: string;
     readonly query: string;
     readonly argument: unknown;
     readonly signal?: AbortSignal;
@@ -37,6 +39,10 @@ export interface DeploymentRuntimeStatus {
     readonly releaseIdentity: string;
     readonly bundleIdentity: string;
 }
+export interface DeploymentRuntimeGeneration {
+    readonly status: DeploymentRuntimeStatus;
+    readonly deployment: ProtocolDeploymentContract;
+}
 export type DeploymentRuntimeReconcileResult = {
     readonly status: 'activated';
     readonly runtime: DeploymentRuntimeStatus;
@@ -55,6 +61,7 @@ export interface DeploymentRuntimeSupervisor {
     }): Promise<DeploymentRuntimeReconcileResult>;
     invoke(input: DeploymentRuntimeInvocation): Promise<unknown>;
     status(target: ProtocolDeploymentReleaseTarget): DeploymentRuntimeStatus | undefined;
+    generation(target: ProtocolDeploymentReleaseTarget): DeploymentRuntimeGeneration | undefined;
     close(): Promise<void>;
 }
 export interface DeploymentRuntimeSupervisorOptions {