@collective-intelligence/external-apps-server-sdk 0.0.0-stage → 0.1.0

package/dist/runtime/express.d.ts

@@ -0,0 +1,644 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { RequestHandler } from 'express';
+
+export type PrincipalKind = "detached_user" | "service_principal";
+export type DelegatedSubjectPolicy = "allowed" | "forbidden" | "required";
+export type AuthorizationRequirement = Readonly<{
+	delegatedSubject?: DelegatedSubjectPolicy;
+	organization: "required";
+	principalKinds: readonly PrincipalKind[];
+	scopes: readonly string[];
+}>;
+export type ExternalAuditSubject = Readonly<{
+	issuer: string;
+	mappedCiUserId?: string;
+	subject: string;
+}>;
+export type GatewayCallerIdentity = Readonly<{
+	audience: readonly string[];
+	binding: string;
+	expiresAt: number;
+	installationId: string;
+	issuer: string;
+	organizationId: string;
+	principalKind: PrincipalKind;
+	requestId: string;
+	scopes: readonly string[];
+	subject: string;
+}>;
+export type GatewayInvocationContext = Readonly<{
+	caller: GatewayCallerIdentity;
+	correlationId: string;
+	externalAuditSubject?: ExternalAuditSubject;
+	organizationId: string;
+}>;
+export type JsonPrimitive = boolean | null | number | string;
+export type JsonValue = JsonObject | JsonPrimitive | readonly JsonValue[];
+export interface JsonObject {
+	readonly [key: string]: JsonValue;
+}
+declare const Draft202012Dialect: "https://json-schema.org/draft/2020-12/schema";
+/** JSON-compatible Draft 2020-12 vocabulary used for portable manifests. */
+export type JsonSchemaDocument = JsonObject & Readonly<{
+	$anchor?: string;
+	$comment?: string;
+	$defs?: Readonly<Record<string, JsonSchemaDocument>>;
+	$dynamicAnchor?: string;
+	$dynamicRef?: string;
+	$id?: string;
+	$ref?: string;
+	$schema?: typeof Draft202012Dialect;
+	additionalProperties?: boolean | JsonSchemaDocument;
+	allOf?: readonly JsonSchemaDocument[];
+	anyOf?: readonly JsonSchemaDocument[];
+	const?: JsonValue;
+	contains?: JsonSchemaDocument;
+	default?: JsonValue;
+	dependentRequired?: Readonly<Record<string, readonly string[]>>;
+	description?: string;
+	else?: JsonSchemaDocument;
+	enum?: readonly JsonValue[];
+	exclusiveMaximum?: number;
+	exclusiveMinimum?: number;
+	format?: string;
+	if?: JsonSchemaDocument;
+	items?: JsonSchemaDocument;
+	maxItems?: number;
+	maxLength?: number;
+	maxProperties?: number;
+	maximum?: number;
+	minItems?: number;
+	minLength?: number;
+	minProperties?: number;
+	minimum?: number;
+	multipleOf?: number;
+	not?: JsonSchemaDocument;
+	oneOf?: readonly JsonSchemaDocument[];
+	pattern?: string;
+	patternProperties?: Readonly<Record<string, JsonSchemaDocument>>;
+	prefixItems?: readonly JsonSchemaDocument[];
+	properties?: Readonly<Record<string, JsonSchemaDocument>>;
+	required?: readonly string[];
+	then?: JsonSchemaDocument;
+	title?: string;
+	type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | readonly ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[];
+	unevaluatedItems?: boolean | JsonSchemaDocument;
+	unevaluatedProperties?: boolean | JsonSchemaDocument;
+	uniqueItems?: boolean;
+}>;
+export type ProjectionFidelity = "exact" | "structural";
+export type PackageSchemaProjection = Readonly<{
+	dialect: typeof Draft202012Dialect;
+	document: JsonSchemaDocument;
+	fidelity: ProjectionFidelity;
+}>;
+/** Closed public principal vocabulary accepted by a gateway operation. */
+export type PortableOperationPrincipalKind = "detached_user" | "service_principal";
+/** Explicit delegated-subject requirement reviewed with an operation. */
+export type PortableOperationDelegatedSubjectPolicy = "allowed" | "forbidden" | "required";
+/** Fully materialized authorization policy for one exposed operation. */
+export type PortableOperationAuthorization = Readonly<{
+	delegatedSubject: PortableOperationDelegatedSubjectPolicy;
+	organization: "required";
+	principalKinds: readonly PortableOperationPrincipalKind[];
+	scopes: readonly string[];
+}>;
+/** Observable side-effect class reviewed before an operation becomes a tool. */
+export type PortableOperationEffect = "external_side_effect" | "read" | "write";
+/** The replay guarantee supplied by the operation implementation. */
+export type PortableOperationIdempotency = "idempotent" | "requires_key" | "safe";
+/** Explicit, bounded retry permission for callers of the operation. */
+export type PortableOperationRetryPolicy = Readonly<{
+	mode: "never";
+}> | Readonly<{
+	maxAttempts: number;
+	mode: "idempotent_only";
+}>;
+/** Execution lifecycle and maximum wall-clock duration. */
+export type PortableOperationExecutionPolicy = Readonly<{
+	mode: "synchronous";
+	timeoutMs: number;
+}>;
+/** Per-invocation transport bounds. */
+export type PortableOperationLimits = Readonly<{
+	maxRequestBytes: number;
+	maxResponseBytes: number;
+}>;
+/**
+ * Complete JSON-only operation contract reviewed by a host. Executable
+ * handlers remain in a server runtime sidecar and never enter this descriptor.
+ */
+export type PortableOperationDeclaration = Readonly<{
+	authorization: PortableOperationAuthorization;
+	description: string;
+	effects: PortableOperationEffect;
+	execution: PortableOperationExecutionPolicy;
+	id: string;
+	idempotency: PortableOperationIdempotency;
+	input: PackageSchemaProjection;
+	limits: PortableOperationLimits;
+	output: PackageSchemaProjection;
+	retry: PortableOperationRetryPolicy;
+	title: string;
+	version: string;
+}>;
+/** One catalog and identity namespace for an ordered operation list. */
+export type OperationDomainDeclaration<Operation extends PortableOperationDeclaration = PortableOperationDeclaration> = Readonly<{
+	description?: string;
+	displayOrder?: number;
+	icon?: string;
+	id: string;
+	operations: readonly Operation[];
+	tags?: readonly string[];
+	title: string;
+}>;
+export type DatasetProviderResult<Value> = Readonly<{
+	status: "success";
+	value: Value;
+}> | Readonly<{
+	status: "failure";
+	error: DatasetProviderError;
+}>;
+export type DatasetScalarType = "boolean" | "string" | "int64" | "float64" | "decimal" | "date" | "timestamp" | "duration" | "json";
+export type DatasetValue = Readonly<{
+	kind: "null";
+}> | Readonly<{
+	kind: "boolean";
+	value: boolean;
+}> | Readonly<{
+	kind: "string";
+	value: string;
+}> | Readonly<{
+	kind: "int64";
+	value: string;
+}> | Readonly<{
+	kind: "float64";
+	value: number;
+}> | Readonly<{
+	kind: "decimal";
+	value: string;
+}> | Readonly<{
+	kind: "date";
+	value: string;
+}> | Readonly<{
+	kind: "timestamp";
+	value: string;
+}> | Readonly<{
+	kind: "duration";
+	value: string;
+}> | Readonly<{
+	kind: "json";
+	value: JsonValue;
+}>;
+export type DatasetPredicateOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "is_null" | "is_not_null" | "contains" | "starts_with";
+export type DatasetAggregateOperation = "count" | "count_distinct" | "sum" | "min" | "max" | "avg";
+export type DatasetQueryIntent = "records" | "aggregate" | "time_series";
+export type DatasetTimeBucket = "hour" | "day" | "week" | "month";
+export type DatasetPredicate = Readonly<{
+	kind: "predicate";
+	fieldId: string;
+	operator: DatasetPredicateOperator;
+	values: readonly DatasetValue[];
+}>;
+export type DatasetFilter = DatasetPredicate | Readonly<{
+	kind: "and" | "or";
+	filters: readonly DatasetFilter[];
+}> | Readonly<{
+	kind: "not";
+	filter: DatasetFilter;
+}>;
+export type DatasetOrder = Readonly<{
+	fieldOrAlias: string;
+	direction: "asc" | "desc";
+}>;
+export type DatasetOperation = Readonly<{
+	kind: "records";
+	projection: readonly string[];
+	filter?: DatasetFilter;
+	orderBy: readonly DatasetOrder[];
+	cursor?: string;
+}> | Readonly<{
+	kind: "aggregate";
+	filter?: DatasetFilter;
+	groupBy: readonly string[];
+	measures: readonly Readonly<{
+		alias: string;
+		operation: DatasetAggregateOperation;
+		fieldId?: string;
+	}>[];
+	orderBy: readonly DatasetOrder[];
+	cursor?: string;
+}> | Readonly<{
+	kind: "time_series";
+	timeFieldId: string;
+	measure: Readonly<{
+		alias: string;
+		operation: DatasetAggregateOperation;
+		fieldId?: string;
+	}>;
+	bucket: DatasetTimeBucket;
+	order: "asc" | "desc";
+	filter?: DatasetFilter;
+	cursor?: string;
+}>;
+export type DatasetProviderCapabilities = Readonly<{
+	intents: readonly DatasetQueryIntent[];
+	predicates: readonly DatasetPredicateOperator[];
+	aggregates: readonly DatasetAggregateOperation[];
+	grouping: boolean;
+	ordering: boolean;
+	pagination: boolean;
+	definitionRefresh: boolean;
+	limits: Readonly<{
+		maxRows: number;
+		maxBytes: number;
+		timeoutMs: number;
+		maxPageRows: number;
+	}>;
+}>;
+export type SafeDiagnostic = Readonly<{
+	code: string;
+	message: string;
+	fieldId?: string;
+}>;
+export type ConnectorContext = Readonly<{
+	correlationId: string;
+	deadlineEpochMs: number;
+}>;
+export type DatasetSourceLocation = Readonly<{
+	segments: readonly [
+		Readonly<{
+			kind: "container";
+			opaqueId: string;
+			label: string;
+		}>,
+		...Readonly<{
+			kind: "container" | "dataset";
+			opaqueId: string;
+			label: string;
+		}>[]
+	];
+}>;
+export type DatasetDefinition = Readonly<{
+	version: 1;
+	fields: readonly Readonly<{
+		id: string;
+		name: string;
+		type: DatasetScalarType;
+		nullable: boolean;
+		semantic?: string;
+	}>[];
+	measures: readonly Readonly<{
+		id: string;
+		name: string;
+		resultType: DatasetScalarType;
+	}>[];
+	relationships: readonly Readonly<{
+		id: string;
+		fromFieldId: string;
+		toFieldId: string;
+		cardinality: "one_to_one" | "one_to_many" | "many_to_one" | "many_to_many";
+	}>[];
+}>;
+export type Bounds = Readonly<{
+	maxRows: number;
+	maxBytes: number;
+	timeoutMs: number;
+}>;
+export type QueryInput = ConnectorContext & Readonly<{
+	location: DatasetSourceLocation;
+	definitionRevisionId: string;
+	definition: DatasetDefinition;
+	operation: DatasetOperation;
+	bounds: Bounds;
+}>;
+export type DatasetRecordPage = Readonly<{
+	columns: readonly Readonly<{
+		fieldId: string;
+		type: DatasetScalarType;
+	}>[];
+	rows: readonly (readonly DatasetValue[])[];
+	nextCursor?: string;
+	rowCount: number;
+	byteCount: number;
+	observedAt: string;
+}>;
+export type DatasetResultPage = (Readonly<{
+	kind: "records";
+}> & DatasetRecordPage) | Readonly<{
+	kind: "aggregate";
+	columns: readonly Readonly<{
+		alias: string;
+		type: DatasetScalarType;
+	}>[];
+	rows: readonly (readonly DatasetValue[])[];
+	nextCursor?: string;
+	rowCount: number;
+	byteCount: number;
+	observedAt: string;
+}> | Readonly<{
+	kind: "time_series";
+	valueType: DatasetScalarType;
+	points: readonly Readonly<{
+		time: string;
+		value: DatasetValue;
+	}>[];
+	nextCursor?: string;
+	pointCount: number;
+	byteCount: number;
+	observedAt: string;
+}>;
+export type DatasetProviderError = Readonly<{
+	kind: "not_ready" | "incompatible_source" | "unsupported_operation" | "policy_not_pushable" | "invalid_cursor" | "timeout" | "permission_denied" | "provider_unavailable" | "provider_rejected" | "invalid_provider_response";
+	diagnostics: readonly SafeDiagnostic[];
+}> | Readonly<{
+	kind: "limit_exceeded";
+	limit: "rows" | "bytes" | "timeout";
+	diagnostics: readonly SafeDiagnostic[];
+}> | Readonly<{
+	kind: "throttled";
+	retryAfterMs?: number;
+	diagnostics: readonly SafeDiagnostic[];
+}>;
+export type ResourceJsonValue = null | boolean | number | string | readonly ResourceJsonValue[] | Readonly<{
+	[key: string]: ResourceJsonValue;
+}>;
+/** Opaque wire identity. Callers must not infer or concatenate its internals. */
+export type ResourceId = string;
+export type ResourceRecordId = ResourceId;
+/** Opaque concurrency token independent from source timestamps. */
+export type ResourceRevision = string;
+/** Opaque pagination position issued and consumed only by a resource adapter. */
+export type ResourceCursor = string;
+export type IdempotencyKey = string;
+export type ResourceIdentityField = Readonly<{
+	name: string;
+	type: "number" | "string";
+}>;
+export type ResourceCapabilities = Readonly<{
+	create?: boolean;
+	/** Common entity deletion is always soft deletion. */
+	delete?: boolean;
+	get?: boolean;
+	hardDelete?: boolean;
+	includeDeleted?: boolean;
+	restore?: boolean;
+	search: true;
+	softDelete?: boolean;
+	update?: boolean;
+}>;
+export type ResourcePaginationMode = "cursor" | "page";
+export type PortableResourceSchema = Readonly<Record<string, ResourceJsonValue>>;
+export type ResourceDefinition<Entity, Create = Entity, Update = Partial<Entity>> = Readonly<{
+	capabilities: ResourceCapabilities;
+	concurrency: "revision";
+	id: string;
+	identity: Readonly<{
+		fields: readonly [
+			ResourceIdentityField,
+			...ResourceIdentityField[]
+		];
+	}>;
+	query: Readonly<{
+		filterableFields: readonly string[];
+		pagination: Readonly<{
+			modes: readonly ResourcePaginationMode[];
+		}>;
+		sortableFields: readonly string[];
+		textSearchFields?: readonly string[];
+	}>;
+	schemas: Readonly<{
+		create?: PortableResourceSchema;
+		entity: PortableResourceSchema;
+		update?: PortableResourceSchema;
+	}>;
+	version: string;
+	/** Portable UI metadata; required/enum/nullability remain in schemas. */
+	metadata?: Readonly<Record<string, ResourceJsonValue>>;
+	/** Type-only slots keep definition values portable and serializable. */
+	readonly __types?: Readonly<{
+		create: Create;
+		entity: Entity;
+		update: Update;
+	}>;
+}>;
+export type FilterValue = ResourceJsonValue | readonly ResourceJsonValue[];
+export type ResourceFilter = Readonly<{
+	field: string;
+	operator: "contains" | "ends_with" | "eq" | "gt" | "gte" | "in" | "lt" | "lte" | "ne" | "not_in" | "starts_with";
+	value: FilterValue;
+}> | Readonly<{
+	field: string;
+	operator: "is_not_null" | "is_null";
+}> | Readonly<{
+	filters: readonly ResourceFilter[];
+	operator: "and" | "or";
+}> | Readonly<{
+	filter: ResourceFilter;
+	operator: "not";
+}>;
+export type ResourceSort = Readonly<{
+	direction: "asc" | "desc";
+	field: string;
+}>;
+export type ResourcePagination = Readonly<{
+	mode: "cursor";
+	cursor?: ResourceCursor;
+	limit: number;
+}> | Readonly<{
+	mode: "page";
+	page: number;
+	pageSize: number;
+}>;
+export type ResourceListQuery = Readonly<{
+	filter?: ResourceFilter;
+	includeDeleted?: boolean;
+	pagination: ResourcePagination;
+	sort?: readonly ResourceSort[];
+	textSearch?: string;
+}>;
+export type ResourceErrorCode = "capability_not_supported" | "conflict" | "forbidden" | "internal" | "invalid_request" | "not_found" | "rate_limited" | "transport_error" | "unauthenticated" | "unavailable";
+export type ResourceError = Readonly<{
+	code: ResourceErrorCode;
+	/** Client-observed dispatch outcome; uncertainty never proves rollback. */
+	outcome?: "not_dispatched" | "rejected" | "uncertain";
+	details?: Readonly<Record<string, ResourceJsonValue>>;
+	message: string;
+	retryable: boolean;
+}>;
+export type ResourceResult<Value> = Readonly<{
+	correlationId: string;
+	ok: true;
+	value: Value;
+}> | Readonly<{
+	correlationId: string;
+	error: ResourceError;
+	ok: false;
+}>;
+export type ResourceListRequest = Readonly<{
+	operation: "list";
+	query: ResourceListQuery;
+	requestId: string;
+	resourceId: string;
+}>;
+export type ResourceGetRequest = Readonly<{
+	id: ResourceRecordId;
+	includeDeleted?: boolean;
+	operation: "get";
+	requestId: string;
+	resourceId: string;
+}>;
+export type ResourceCreateRequest<Create> = Readonly<{
+	idempotencyKey: IdempotencyKey;
+	operation: "create";
+	requestId: string;
+	resourceId: string;
+	value: Create;
+}>;
+export type ResourceUpdateRequest<Update> = Readonly<{
+	expectedRevision: ResourceRevision;
+	id: ResourceRecordId;
+	idempotencyKey?: IdempotencyKey;
+	operation: "update";
+	requestId: string;
+	resourceId: string;
+	value: Update;
+}>;
+export type ResourceLifecycleRequest = Readonly<{
+	expectedRevision: ResourceRevision;
+	id: ResourceRecordId;
+	idempotencyKey?: IdempotencyKey;
+	operation: "hard_delete" | "restore" | "soft_delete";
+	requestId: string;
+	resourceId: string;
+}>;
+export type ResourceTransportRequest = ResourceCreateRequest<unknown> | ResourceGetRequest | ResourceLifecycleRequest | ResourceListRequest | ResourceUpdateRequest<unknown>;
+/** Full inventory only: no filters, text search or caller-selected ordering.
+ * Continue consecutive pages with the first watermark. A conflict requires restart.
+ */
+export type ResourceInventoryRequest = Readonly<{
+	page: number;
+	pageSize: number;
+	watermark?: string;
+}>;
+export type GatewayResourceOperation = ResourceTransportRequest["operation"];
+export type GatewayResourceAuthorization = Readonly<Partial<Record<GatewayResourceOperation, AuthorizationRequirement>>>;
+export type GatewayResourceDefinition<Entity = unknown, Create = Entity, Update = Partial<Entity>> = Readonly<{
+	authorization: GatewayResourceAuthorization;
+	definition: ResourceDefinition<Entity, Create, Update>;
+	execute: (request: ResourceTransportRequest, context: GatewayInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<unknown>>;
+	scan?: (request: ResourceInventoryRequest & Readonly<{
+		requestId: string;
+		resourceId: string;
+	}>, context: GatewayInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<unknown>>;
+	changes?: (request: Readonly<{
+		cursor?: string;
+		limit: number;
+		requestId: string;
+		resourceId: string;
+	}>, context: GatewayInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<unknown>>;
+}>;
+/**
+ * Runtime dispatch validates the declared input schema before invoking a
+ * handler. The bivariant call signature lets domains retain heterogeneous,
+ * strongly typed handlers while exposing one erased operation collection.
+ */
+export type GatewayOperationHandler<Input = unknown, Output = unknown> = {
+	bivarianceHack(request: Readonly<{
+		context: GatewayInvocationContext;
+		/** Validated caller key; the handler owns durable replay storage. */
+		idempotencyKey?: string;
+		input: Input;
+		signal: AbortSignal;
+	}>): Promise<Output>;
+}["bivarianceHack"];
+export type GatewayOperationDefinition<Input = unknown, Output = unknown> = Omit<PortableOperationDeclaration, "input" | "output"> & Readonly<{
+	handler: GatewayOperationHandler<Input, Output>;
+	input: PackageSchemaProjection;
+	output: PackageSchemaProjection;
+}>;
+export type GatewayOperationManifest = Omit<GatewayOperationDefinition, "handler"> & Readonly<{
+	canonicalReference: string;
+}>;
+export type GatewayOperationDomainDefinition = OperationDomainDeclaration<GatewayOperationDefinition>;
+export type GatewayOperationDomainManifest = OperationDomainDeclaration<GatewayOperationManifest>;
+/** CI destination marker only; source records are shared across all connections. */
+export type OrganizationBinding = Readonly<{
+	mode: "installed_organization";
+}>;
+export type GatewayKnowledgeResourceExposure = Readonly<{
+	resource: GatewayResourceDefinition;
+	access: "read" | "read_write";
+}>;
+export type GatewayDatasetBinding = Readonly<{
+	id: string;
+	title: string;
+	definition: DatasetDefinition;
+	authorization: AuthorizationRequirement;
+	providerFqn: string;
+	query: (input: QueryInput, context: GatewayInvocationContext, options: Readonly<{
+		signal: AbortSignal;
+	}>) => Promise<DatasetProviderResult<DatasetResultPage>>;
+}>;
+export type GatewayDatasetManifest = Omit<GatewayDatasetBinding, "query"> & Readonly<{
+	capabilities: DatasetProviderCapabilities;
+}>;
+export type GatewayDefinitionInput = Readonly<{
+	knowledge?: readonly GatewayKnowledgeResourceExposure[];
+	datasets?: readonly GatewayDatasetBinding[];
+	id: string;
+	operationDomains: readonly GatewayOperationDomainDefinition[];
+	organizationBinding?: OrganizationBinding;
+	protocolVersion?: "2";
+	version: string;
+}>;
+export type GatewayManifest = Readonly<{
+	capabilities: Readonly<{
+		resources: boolean;
+	}>;
+	datasets: readonly GatewayDatasetManifest[];
+	knowledge: readonly Readonly<{
+		id: string;
+		access: "read" | "read_write";
+		definition: GatewayResourceDefinition["definition"];
+		fullInventory: boolean;
+		incrementalChanges: boolean;
+	}>[];
+	contentHash: string;
+	id: string;
+	operationDomains: readonly GatewayOperationDomainManifest[];
+	organizationBinding: OrganizationBinding;
+	protocolVersion: "2";
+	revision: string;
+	version: string;
+}>;
+export type GatewayProposal = Readonly<{
+	gatewayId: string;
+	gatewayVersion: string;
+	knowledge: GatewayManifest["knowledge"];
+	operationDomains: readonly GatewayOperationDomainManifest[];
+	revision: string;
+}>;
+export interface DefinedGateway {
+	readonly input: GatewayDefinitionInput;
+	readonly resource: (id: string) => GatewayResourceDefinition | undefined;
+	readonly dataset: (id: string) => GatewayDatasetBinding | undefined;
+	readonly manifest: GatewayManifest;
+	readonly proposal: GatewayProposal;
+}
+export interface GatewayKernel {
+	readonly handle: (request: Request) => Promise<Response>;
+	readonly manifest: DefinedGateway["manifest"];
+}
+export type GatewayRuntimeKernel = Pick<GatewayKernel, "handle">;
+export type ServerSdkExpressMiddleware = RequestHandler;
+export declare const createGatewayExpressMiddleware: (kernel: GatewayRuntimeKernel) => ServerSdkExpressMiddleware, serverSdkExpressEntrypoint: "express";
+
+export {};

package/dist/runtime/express.js

@@ -0,0 +1 @@
+var __defProp=Object.defineProperty;var __returnValue=(v)=>v;function __exportSetter(name,newValue){this[name]=__returnValue.bind(null,newValue)}var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:true,configurable:true,set:__exportSetter.bind(all,name)})};var exports_express={};__export(exports_express,{serverSdkExpressEntrypoint:()=>serverSdkExpressEntrypoint,createGatewayExpressMiddleware:()=>createGatewayExpressMiddleware});var headersFromNode=(input)=>{const headers=new Headers;for(const[name,value]of Object.entries(input)){if(typeof value==="string"){headers.set(name,value)}else if(Array.isArray(value)){headers.set(name,value.join(", "))}}return headers};var nodeChunk=(chunk)=>{if(typeof chunk==="string"){return new TextEncoder().encode(chunk)}return chunk};var bodyFromNode=(request,onBodyCancelled)=>{if(request.body!==undefined){return typeof request.body==="string"?request.body:JSON.stringify(request.body)}const iterator=request.iterator?.({destroyOnReturn:false})??request[Symbol.asyncIterator]?.();if(iterator===undefined){return}return new ReadableStream({cancel:async()=>{onBodyCancelled?.();await iterator.return?.()},pull:async(controller)=>{try{const next=await iterator.next();if(next.done===true){controller.close()}else{controller.enqueue(nodeChunk(next.value))}}catch(error){controller.error(error)}}},{highWaterMark:0})};var webRequestFromNode=async(request,signal,onBodyCancelled)=>{const method=request.method??"GET";const headers=headersFromNode(request.headers);const host=headers.get("host")??"gateway.local";const protocol=request.protocol??"http";const url=new URL(request.originalUrl??request.url??"/",`${protocol}://${host}`);const body=method==="GET"||method==="HEAD"?undefined:bodyFromNode(request,onBodyCancelled);const requestInit={headers,method,signal};if(body!==undefined){requestInit.body=body;requestInit.duplex="half"}return new Request(url,requestInit)};var sendWebResponseToNode=async(response,result)=>{if(response.status===undefined){response.statusCode=result.status}else{response.status(result.status)}for(const[name,value]of result.headers){if(response.setHeader===undefined){response.header?.(name,value)}else{response.setHeader(name,value)}}if(result.body===null){response.end();return}const reader=result.body.getReader();while(true){const next=await reader.read();if(next.done){break}response.write?.(next.value)}response.end()};var handleNodeRequest=async(kernel,request,response)=>{const controller=new AbortController;const onAborted=()=>{controller.abort()};request.once?.("aborted",onAborted);response?.once?.("close",onAborted);try{let bodyCancelled=false;let result=await kernel.handle(await webRequestFromNode(request,controller.signal,()=>{bodyCancelled=true}));if(bodyCancelled){const headers=new Headers(result.headers);headers.set("connection","close");result=new Response(result.body,{headers,status:result.status,statusText:result.statusText})}if(response!==undefined){await sendWebResponseToNode(response,result.clone())}return result}finally{request.off?.("aborted",onAborted);response?.off?.("close",onAborted)}};var createGatewayExpressMiddleware=(kernel)=>(request,response,next)=>{const nodeRequest={[Symbol.asyncIterator]:()=>request[Symbol.asyncIterator](),body:request.body,headers:request.headers,iterator:(options)=>request.iterator(options),method:request.method,off:(event,listener)=>{request.off(event,listener)},once:(event,listener)=>{request.once(event,listener)},originalUrl:request.url,protocol:request.protocol,url:request.url};const nodeResponse={end:(body)=>{response.end(body)},off:(event,listener)=>{response.off(event,listener)},once:(event,listener)=>{response.once(event,listener)},setHeader:(name,value)=>{response.setHeader(name,value)},status:(status)=>{response.status(status);return nodeResponse},write:(body)=>{response.write(body)}};(async()=>{try{await handleNodeRequest(kernel,nodeRequest,nodeResponse)}catch(error){next(error)}})()};var serverSdkExpressEntrypoint="express";var{createGatewayExpressMiddleware:createGatewayExpressMiddleware2,serverSdkExpressEntrypoint:serverSdkExpressEntrypoint2}=exports_express;export{serverSdkExpressEntrypoint2 as serverSdkExpressEntrypoint,createGatewayExpressMiddleware2 as createGatewayExpressMiddleware};