@powerhousedao/reactor-api 6.0.2-staging.5 → 6.0.2-staging.7

package/dist/index.mjs

@@ -1,4 +1,6 @@
-import { a as isSubgraphClass, c as loadDocumentModels, d as BaseSubgraph, i as buildGraphqlOperations, l as loadProcessors, n as buildGraphQlDriveDocument, o as debounce, r as buildGraphqlOperation, t as buildGraphQlDocument, u as loadSubgraphs } from "./utils-CVrD_vPF.mjs";
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="81df4612-dfa1-5785-acec-bca9f4770f2d")}catch(e){}}();
+import { a as isSubgraphClass, c as loadDocumentModels, d as BaseSubgraph, i as buildGraphqlOperations, l as loadProcessors, n as buildGraphQlDriveDocument, o as debounce, r as buildGraphqlOperation, t as buildGraphQlDocument, u as loadSubgraphs } from "./utils-CHCRSWig.mjs";
 import { AnalyticsQueryEngine } from "@powerhousedao/analytics-engine-core";
 import { AnalyticsModel, AnalyticsResolvers, typedefs } from "@powerhousedao/analytics-engine-graphql";
 import { gql } from "graphql-tag";
@@ -25,19 +27,19 @@ import { match } from "path-to-regexp";
 import fastifyCors from "@fastify/cors";
 import fastifyFormbody from "@fastify/formbody";
 import fastifyMiddie from "@fastify/middie";
-import { execSync } from "node:child_process";
 import { verifyAuthBearerToken } from "@renown/sdk";
 import { buildSubgraphSchema } from "@apollo/subgraph";
 import { typeDefs } from "@powerhousedao/document-engineering/graphql";
 import { camelCase, kebabCase, pascalCase } from "change-case";
 import { GraphQLJSONObject } from "graphql-type-json";
 import { setName } from "@powerhousedao/shared/document-model";
-import { PropagationMode as PropagationMode$1, consolidateSyncOperations, driveIdFromUrl, envelopesToSyncOperations, parseDriveUrl, sortEnvelopesByFirstOperationTimestamp, trimMailboxFromAckOrdinal } from "@powerhousedao/reactor";
+import { PropagationMode as PropagationMode$1, consolidateSyncOperations, driveIdFromUrl, envelopesToSyncOperations, parseDriveUrl } from "@powerhousedao/reactor";
 import * as z$1 from "zod";
 import { z } from "zod";
 import { createHandler } from "graphql-sse/lib/use/fetch";
 import { PubSub, withFilter } from "graphql-subscriptions";
 import dotenv from "dotenv";
+import { buildTreeUrl } from "@powerhousedao/shared";
 import { getConfig } from "@powerhousedao/config/node";
 import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
 import EventEmitter from "node:events";
@@ -49,15 +51,6 @@ import { tmpdir } from "node:os";
 import { WebSocketServer } from "ws";
 import { createRelationalDb } from "@powerhousedao/shared/processors";
 import { Kysely, Migrator, sql } from "kysely";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { PrometheusExporter } from "@opentelemetry/exporter-prometheus";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { Resource } from "@opentelemetry/resources";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
 import { PGlite } from "@electric-sql/pglite";
 import knex from "knex";
 import ClientPgLite from "knex-pglite";
@@ -563,6 +556,7 @@ var ApolloGatewayAdapter = class {
 			schema,
 			logger: this.#logger,
 			introspection: true,
+			stopOnTerminationSignals: false,
 			plugins: [ApolloServerPluginInlineTraceDisabled(), ApolloServerPluginLandingPageLocalDefault()]
 		});
 		await server.start();
@@ -582,6 +576,7 @@ var ApolloGatewayAdapter = class {
 			}),
 			logger: this.#logger,
 			introspection: true,
+			stopOnTerminationSignals: false,
 			plugins: [
 				ApolloServerPluginDrainHttpServer({ httpServer }),
 				ApolloServerPluginInlineTraceDisabled(),
@@ -926,7 +921,7 @@ function parseBodyLimit(limit) {
 var FastifyHttpAdapter = class {
 	#fetchRoutes = [];
 	#getRoutes = /* @__PURE__ */ new Map();
-	#nodeRoutes = /* @__PURE__ */ new Map();
+	#nodeRoutes = [];
 	#setupOps = [];
 	#instance;
 	get handle() {
@@ -953,8 +948,11 @@ var FastifyHttpAdapter = class {
 		});
 	}
 	mountNodeRoute(method, path, handler) {
-		if (!this.#nodeRoutes.has(path)) this.#nodeRoutes.set(path, /* @__PURE__ */ new Map());
-		this.#nodeRoutes.get(path).set(method, handler);
+		this.#nodeRoutes.push({
+			method,
+			matcher: match(normalizePath(path)),
+			handler
+		});
 	}
 	mountRawMiddleware(middleware) {
 		if (this.#instance) this.#instance.use(middleware);
@@ -1024,14 +1022,14 @@ var FastifyHttpAdapter = class {
 	#dispatch(req, reply) {
 		const pathname = new URL(req.url, "http://localhost").pathname;
 		const method = req.method.toUpperCase();
-		const nodeHandlers = this.#nodeRoutes.get(pathname);
-		if (nodeHandlers) {
-			const handler = nodeHandlers.get(method);
-			if (handler) {
-				reply.hijack();
-				handler(req.raw, reply.raw, req.body);
-				return;
-			}
+		for (const entry of this.#nodeRoutes) {
+			if (entry.method !== method) continue;
+			const result = entry.matcher(pathname);
+			if (!result) continue;
+			req.raw.params = result.params;
+			reply.hijack();
+			entry.handler(req.raw, reply.raw, req.body);
+			return;
 		}
 		if (method === "GET") {
 			for (const entry of this.#getRoutes.values()) if (entry.matcher(pathname)) return this.#serveGetEntry(entry, req, reply);
@@ -2719,9 +2717,13 @@ function matchesJobFilter(payload, args) {
 	return payload.jobId === args.jobId;
 }
 //#endregion
-//#region src/graphql/reactor/resolvers.ts
+//#region src/graphql/reactor/constants.ts
+/**
+* Document-type sentinel for drive documents. Drives are the unit
+* the LB shards on (via the `Drive-Id` request header) and the unit
+* the drive-ownership cache tracks on each switchboard instance.
+*/
 const DRIVE_DOCUMENT_TYPE = "powerhouse/document-drive";
-const POLL_SYNC_ENVELOPES_MAX_LIMIT = 100;
 async function documentModels(reactorClient, args) {
 	const namespace = fromInputMaybe(args.namespace);
 	let paging;
@@ -2917,7 +2919,7 @@ async function createDocument(reactorClient, args) {
 	const parentIdentifier = fromInputMaybe(args.parentIdentifier);
 	let result;
 	try {
-		if (parentIdentifier) if ((await reactorClient.get(parentIdentifier)).header.documentType === DRIVE_DOCUMENT_TYPE) result = await reactorClient.drives.addFile(parentIdentifier, document);
+		if (parentIdentifier) if ((await reactorClient.get(parentIdentifier)).header.documentType === "powerhouse/document-drive") result = await reactorClient.drives.addFile(parentIdentifier, document);
 		else result = await reactorClient.create(document, parentIdentifier);
 		else result = await reactorClient.create(document);
 	} catch (error) {
@@ -2934,7 +2936,7 @@ async function createEmptyDocument(reactorClient, args) {
 	const name = fromInputMaybe(args.name);
 	let result;
 	try {
-		if (parentIdentifier) if ((await reactorClient.get(parentIdentifier)).header.documentType === DRIVE_DOCUMENT_TYPE) {
+		if (parentIdentifier) if ((await reactorClient.get(parentIdentifier)).header.documentType === "powerhouse/document-drive") {
 			const document = (await reactorClient.getDocumentModelModule(args.documentType)).utils.createDocument();
 			if (name) document.header.name = name;
 			result = await reactorClient.drives.addFile(parentIdentifier, document);
@@ -2981,7 +2983,7 @@ async function createDocumentWithInitialState(reactorClient, args) {
 		} catch (error) {
 			throw new GraphQLError(`Parent document not found: ${error instanceof Error ? error.message : "Unknown error"}`);
 		}
-		if (parent.header.documentType === DRIVE_DOCUMENT_TYPE) try {
+		if (parent.header.documentType === "powerhouse/document-drive") try {
 			result = await reactorClient.drives.addFile(parentIdentifier, document);
 		} catch (error) {
 			throw new GraphQLError(`Failed to create document in drive: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -3172,14 +3174,22 @@ function pollSyncEnvelopes(syncManager, args) {
 		scopes: syncOp.scopes,
 		operationCount: syncOp.operations.length
 	}));
-	if (args.outboxAck > 0) trimMailboxFromAckOrdinal(remote.channel.outbox, args.outboxAck);
-	let operations = remote.channel.outbox.items;
-	operations = operations.filter((syncOp) => {
-		let maxOrdinal = 0;
-		for (const op of syncOp.operations) maxOrdinal = Math.max(maxOrdinal, op.context.ordinal);
-		if (maxOrdinal > args.outboxLatest) return true;
-		return false;
-	});
+	if (args.outboxAck > 0) {
+		const ackOrdinal = args.outboxAck;
+		const outbox = remote.channel.outbox;
+		const toRemove = [];
+		for (const syncOp of outbox.items) {
+			if (!((syncOp.emittedCount ?? 0) >= syncOp.operations.length)) continue;
+			let maxOrdinal = 0;
+			for (const op of syncOp.operations) if (op.context.ordinal > maxOrdinal) maxOrdinal = op.context.ordinal;
+			if (maxOrdinal <= ackOrdinal) toRemove.push(syncOp);
+		}
+		if (toRemove.length > 0) {
+			for (const syncOp of toRemove) syncOp.executed();
+			outbox.remove(...toRemove);
+		}
+	}
+	const operations = remote.channel.outbox.items;
 	if (operations.length === 0) return {
 		envelopes: [],
 		ackOrdinal: remote.channel.inbox.ackOrdinal,
@@ -3189,29 +3199,66 @@ function pollSyncEnvelopes(syncManager, args) {
 	const sorted = [...operations].sort((a, b) => {
 		return (a.operations[0]?.context.ordinal ?? 0) - (b.operations[0]?.context.ordinal ?? 0);
 	});
-	const hasMore = sorted.length > POLL_SYNC_ENVELOPES_MAX_LIMIT;
-	const pageOperations = sorted.slice(0, POLL_SYNC_ENVELOPES_MAX_LIMIT);
+	const envelopes = [];
+	let pageOps = 0;
+	let hasMore = false;
 	let maxOrdinal = args.outboxLatest;
-	for (const syncOp of pageOperations) for (const op of syncOp.operations) {
-		const opOrdinal = op.context.ordinal;
-		if (opOrdinal > maxOrdinal) maxOrdinal = opOrdinal;
+	outer: for (const syncOp of sorted) {
+		if (pageOps >= 100) {
+			hasMore = true;
+			break;
+		}
+		syncOp.deliveredCount ??= 0;
+		syncOp.emittedCount ??= 0;
+		while (syncOp.deliveredCount < syncOp.emittedCount && syncOp.operations[syncOp.deliveredCount].context.ordinal <= args.outboxLatest) syncOp.deliveredCount += 1;
+		const remaining = syncOp.operations.slice(syncOp.deliveredCount);
+		if (remaining.length === 0) continue;
+		let prevPartKey;
+		let partIdx = 0;
+		let i = 0;
+		while (i < remaining.length) {
+			if (pageOps >= 100) {
+				hasMore = true;
+				break outer;
+			}
+			const remainingPage = 100 - pageOps;
+			const chunkSize = Math.max(1, Math.min(25, remainingPage, remaining.length - i));
+			const slice = remaining.slice(i, i + chunkSize);
+			const isOnly = remaining.length <= 25 && remaining.length <= remainingPage;
+			const baseKey = syncOp.jobId || void 0;
+			const partKey = isOnly ? baseKey : baseKey ? `${baseKey}__p${partIdx}` : void 0;
+			const partDeps = partIdx === 0 ? syncOp.jobDependencies.filter(Boolean) : prevPartKey ? [prevPartKey] : [];
+			for (const op of slice) if (op.context.ordinal > maxOrdinal) maxOrdinal = op.context.ordinal;
+			envelopes.push({
+				type: "OPERATIONS",
+				channelMeta: { id: args.channelId },
+				operations: slice.map((op) => ({
+					operation: serializeOperationForGraphQL(op.operation),
+					context: op.context
+				})),
+				cursor: {
+					remoteName: remote.name,
+					cursorOrdinal: 0,
+					lastSyncedAtUtcMs: Date.now().toString()
+				},
+				key: partKey,
+				dependsOn: partDeps.length > 0 ? partDeps : void 0
+			});
+			pageOps += slice.length;
+			i += slice.length;
+			prevPartKey = partKey;
+			partIdx++;
+			const emittedThrough = syncOp.deliveredCount + i;
+			if (emittedThrough > syncOp.emittedCount) syncOp.emittedCount = emittedThrough;
+			if (i < remaining.length && pageOps >= 100) {
+				hasMore = true;
+				break outer;
+			}
+		}
 	}
+	for (const envelope of envelopes) if (envelope.cursor) envelope.cursor.cursorOrdinal = maxOrdinal;
 	return {
-		envelopes: sortEnvelopesByFirstOperationTimestamp(pageOperations.map((syncOp) => ({
-			type: "OPERATIONS",
-			channelMeta: { id: args.channelId },
-			operations: syncOp.operations.map((op) => ({
-				operation: serializeOperationForGraphQL(op.operation),
-				context: op.context
-			})),
-			cursor: {
-				remoteName: remote.name,
-				cursorOrdinal: maxOrdinal,
-				lastSyncedAtUtcMs: Date.now().toString()
-			},
-			key: syncOp.jobId || void 0,
-			dependsOn: syncOp.jobDependencies.filter(Boolean).length > 0 ? syncOp.jobDependencies.filter(Boolean) : void 0
-		}))),
+		envelopes,
 		ackOrdinal: remote.channel.inbox.ackOrdinal,
 		deadLetters,
 		hasMore
@@ -3226,9 +3273,8 @@ function pollSyncEnvelopes(syncManager, args) {
 * and returns the highest one as `ackOrdinal` in pollSyncEnvelopes.
 */
 function pushSyncEnvelopes(syncManager, args) {
-	const sortedEnvelopes = sortEnvelopesByFirstOperationTimestamp(args.envelopes);
 	const remoteSyncOps = /* @__PURE__ */ new Map();
-	for (const envelope of sortedEnvelopes) {
+	for (const envelope of args.envelopes) {
 		let remote;
 		try {
 			remote = syncManager.getById(envelope.channelMeta.id);
@@ -3476,6 +3522,110 @@ var DocumentModelSubgraph = class extends BaseSubgraph {
 	}
 };
 //#endregion
+//#region src/graphql/gateway/drive-middleware.ts
+const DRIVE_ID_HEADER = "drive-id";
+/**
+* Operations that legitimately run before the target drive exists in the
+* cache. Drive creation is the obvious case (a brand-new drive cannot be
+* in the ownership set yet); other create-shaped operations that may
+* synthesize a drive must be added here too.
+*/
+const CACHE_BYPASS_OPERATIONS = new Set(["createDocument", "createEmptyDocument"]);
+const driveIdMap = /* @__PURE__ */ new WeakMap();
+/** Internal — only `graphql-manager.ts` should call this. */
+function getRequestDriveId(request) {
+	return driveIdMap.get(request);
+}
+/**
+* Returns a fetch middleware that validates the `Drive-Id` header against
+* the in-memory ownership cache. Layout:
+*
+* - No header → pass through. The LB has already round-robined; nothing
+*   to validate here.
+* - Header present and drive in cache → record on the request map (for
+*   the context factory to read into `context.driveId`) and pass through.
+* - Header present, drive missing, but the operation is `createDocument`
+*   or `createEmptyDocument` → pass through. The drive may be in the
+*   process of being created.
+* - Otherwise → return `421 Misdirected Request` with a structured body.
+*   The client (or LB) can surface this as a wrong-shard signal.
+*/
+function createDriveFetchMiddleware(cache) {
+	return (next) => async (request) => {
+		const driveId = request.headers.get(DRIVE_ID_HEADER) ?? "";
+		if (driveId === "") return next(request);
+		if (cache.has(driveId)) {
+			driveIdMap.set(request, driveId);
+			return next(request);
+		}
+		if (await isCacheBypassOperation(request)) return next(request);
+		return wrongShardResponse(driveId);
+	};
+}
+async function isCacheBypassOperation(request) {
+	if (request.method !== "POST") return false;
+	try {
+		const body = await request.clone().json();
+		if (typeof body.operationName === "string") return CACHE_BYPASS_OPERATIONS.has(body.operationName);
+		if (typeof body.query === "string") return CACHE_BYPASS_OPERATIONS.has(extractOperationName(body.query));
+		return false;
+	} catch {
+		return false;
+	}
+}
+const OPERATION_NAME_PATTERN = /\b(?:mutation|query|subscription)\s+(\w+)/;
+function extractOperationName(query) {
+	const match = OPERATION_NAME_PATTERN.exec(query);
+	return match ? match[1] : "";
+}
+function wrongShardResponse(driveId) {
+	return new globalThis.Response(JSON.stringify({
+		error: "wrong-shard",
+		driveId
+	}), {
+		status: 421,
+		headers: { "content-type": "application/json" }
+	});
+}
+//#endregion
+//#region src/graphql/gateway/drive-ownership-cache.ts
+/**
+* In-memory record of which drives this switchboard instance owns.
+*
+* Populated at startup by walking the reactor for documents of type
+* `powerhouse/document-drive`. Mutated explicitly by resolver hooks
+* after successful drive create / delete operations. Read by the
+* drive-validation fetch middleware to short-circuit wrong-shard
+* requests with a structured 421 response.
+*/
+var DriveOwnershipCache = class {
+	drives = /* @__PURE__ */ new Set();
+	constructor(reactorClient) {
+		this.reactorClient = reactorClient;
+	}
+	async init() {
+		this.drives.clear();
+		let page = await this.reactorClient.find({ type: DRIVE_DOCUMENT_TYPE });
+		while (true) {
+			for (const drive of page.results) this.drives.add(drive.header.id);
+			if (!page.next) return;
+			page = await page.next();
+		}
+	}
+	has(driveId) {
+		return this.drives.has(driveId);
+	}
+	add(driveId) {
+		this.drives.add(driveId);
+	}
+	remove(driveId) {
+		this.drives.delete(driveId);
+	}
+	size() {
+		return this.drives.size;
+	}
+};
+//#endregion
 //#region src/graphql/sse.ts
 /**
 * Create a Fetch-API-compatible SSE handler for GraphQL subscriptions
@@ -3539,6 +3689,8 @@ var GraphQLManager = class {
 	authService = null;
 	subgraphWsDisposers = /* @__PURE__ */ new Map();
 	#authMiddleware;
+	#driveMiddleware;
+	driveOwnershipCache;
 	/** Cached document models for schema generation - updated on init and regenerate */
 	cachedDocumentModels = [];
 	subgraphHandlerCache = /* @__PURE__ */ new Map();
@@ -3559,11 +3711,15 @@ var GraphQLManager = class {
 		this.port = port;
 		this.authorizationService = authorizationService;
 		if (this.authConfig) this.authService = new AuthService(this.authConfig);
+		this.driveOwnershipCache = new DriveOwnershipCache(this.reactorClient);
 		this.wsServer.setMaxListeners(0);
 	}
 	async init(coreSubgraphs, authMiddleware) {
 		this.#authMiddleware = authMiddleware;
 		this.logger.debug(`Initializing Subgraph Manager...`);
+		await this.driveOwnershipCache.init();
+		this.#driveMiddleware = createDriveFetchMiddleware(this.driveOwnershipCache);
+		this.logger.debug(`Drive ownership cache populated with ${this.driveOwnershipCache.size()} drives`);
 		const models = (await this.reactorClient.getDocumentModelModules()).results;
 		this.cachedDocumentModels = models;
 		if (!models.find((it) => it.documentModel.global.name === "DocumentDrive")) throw new Error("DocumentDrive model required");
@@ -3578,12 +3734,12 @@ var GraphQLManager = class {
 			if (!driveIdOrSlug) return Response.json({ error: "Drive ID or slug is required" }, { status: 400 });
 			try {
 				const driveDoc = await this.reactorClient.get(driveIdOrSlug);
-				const graphqlEndpoint = `${(request.headers.get("x-forwarded-proto") ?? url.protocol.replace(":", "")) + ":"}//${request.headers.get("host") ?? ""}${this.path === "/" ? "" : this.path}/graphql/r`;
+				const graphqlEndpoint = `${(request.headers.get("x-forwarded-proto")?.split(",")[0].trim() ?? url.protocol.replace(":", "")) + ":"}//${request.headers.get("x-forwarded-host")?.split(",")[0].trim() ?? request.headers.get("host") ?? ""}${(request.headers.get("x-forwarded-prefix")?.split(",")[0].trim().replace(/\/$/, "") ?? "") + (this.path === "/" ? "" : this.path)}/graphql/r`;
 				return Response.json({
 					id: driveDoc.header.id,
 					slug: driveDoc.header.slug,
 					meta: driveDoc.header.meta,
-					name: driveDoc.state.global.name,
+					name: driveDoc.state.global.name || driveDoc.header.name,
 					icon: driveDoc.state.global.icon ?? void 0,
 					...graphqlEndpoint && { graphqlEndpoint }
 				});
@@ -3723,6 +3879,7 @@ var GraphQLManager = class {
 	#makeContextFactory() {
 		return (request) => {
 			const authCtx = getAuthContext(request);
+			const driveId = getRequestDriveId(request);
 			const headers = {};
 			request.headers.forEach((v, k) => {
 				headers[k] = v;
@@ -3731,6 +3888,7 @@ var GraphQLManager = class {
 				headers,
 				db: this.relationalDb,
 				...this.getAdditionalContextFields(),
+				driveId,
 				user: authCtx?.user,
 				isAdmin: authCtx ? (addr) => !authCtx.auth_enabled ? true : authCtx.admins.includes(addr.toLowerCase()) : () => true
 			});
@@ -3769,7 +3927,7 @@ var GraphQLManager = class {
 				if (this.subgraphHandlerCache.has(subgraphPath)) continue;
 				const schema = createSchema(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
 				const rawHandler = await this.gatewayAdapter.createHandler(schema, this.#makeContextFactory());
-				const fetchHandler = this.#authMiddleware ? this.#authMiddleware(rawHandler) : rawHandler;
+				const fetchHandler = this.#composeFetchMiddleware(rawHandler);
 				this.subgraphHandlerCache.set(subgraphPath, fetchHandler);
 				this.httpAdapter.mount(subgraphPath, fetchHandler);
 				if (subgraph.hasSubscriptions) {
@@ -3819,7 +3977,7 @@ var GraphQLManager = class {
 	async #createSupergraphGateway() {
 		const superGraphPath = path.join(this.path, "graphql");
 		const rawHandler = await this.gatewayAdapter.createSupergraphHandler(() => this.#getSubgraphDefinitions(), this.httpServer, this.#makeContextFactory());
-		const fetchHandler = this.#authMiddleware ? this.#authMiddleware(rawHandler) : rawHandler;
+		const fetchHandler = this.#composeFetchMiddleware(rawHandler);
 		this.httpAdapter.mount(superGraphPath, fetchHandler);
 		this.#setupSupergraphSSE(superGraphPath);
 		if (!this.initialized) {
@@ -3859,9 +4017,20 @@ var GraphQLManager = class {
 			schema,
 			contextFactory: this.#makeContextFactory()
 		});
-		const handler = this.#authMiddleware ? this.#authMiddleware(rawHandler) : rawHandler;
+		const handler = this.#composeFetchMiddleware(rawHandler);
 		this.httpAdapter.mount(ssePath, handler, { exact: true });
 	}
+	/**
+	* Compose the request-level fetch middleware chain. Auth runs first
+	* (so we don't validate shard before knowing the request is even
+	* authorized), drive-ownership validation runs after.
+	*/
+	#composeFetchMiddleware(rawHandler) {
+		let handler = rawHandler;
+		if (this.#driveMiddleware) handler = this.#driveMiddleware(handler);
+		if (this.#authMiddleware) handler = this.#authMiddleware(handler);
+		return handler;
+	}
 };
 //#endregion
 //#region src/graphql/packages/resolvers.ts
@@ -4377,6 +4546,21 @@ var ReactorSubgraph = class extends BaseSubgraph {
 			await this.assertCanExecuteOperation(documentId, operationType, ctx);
 		}
 	}
+	/**
+	* Returns the drive id when the given identifier (id or slug) refers
+	* to a drive document, otherwise undefined. Used by deleteDocument to
+	* decide whether to invalidate the drive-ownership cache after a
+	* successful delete.
+	*/
+	async #resolveDriveId(identifier) {
+		try {
+			const doc = await this.reactorClient.get(identifier);
+			if (doc.header.documentType === "powerhouse/document-drive") return doc.header.id;
+			return;
+		} catch {
+			return;
+		}
+	}
 	typeDefs = gql(schema_default);
 	resolvers = {
 		PHDocument: { operations: async (parent, args, ctx) => {
@@ -4517,6 +4701,7 @@ var ReactorSubgraph = class extends BaseSubgraph {
 						if (!ctx.user?.address) throw new GraphQLError("Forbidden: authentication required to create documents");
 					} else if (!this.hasGlobalAdminAccess(ctx)) throw new GraphQLError("Forbidden: insufficient permissions to create documents");
 					const result = await createDocument(this.reactorClient, args);
+					if (result?.id && result.documentType === "powerhouse/document-drive") this.graphqlManager.driveOwnershipCache.add(result.id);
 					if (this.authorizationService && ctx.user?.address && result?.id) await this.documentPermissionService?.initializeDocumentProtection(result.id, ctx.user.address, this.authorizationService.config.defaultProtection);
 					return result;
 				} catch (error) {
@@ -4534,6 +4719,7 @@ var ReactorSubgraph = class extends BaseSubgraph {
 						if (!ctx.user?.address) throw new GraphQLError("Forbidden: authentication required to create documents");
 					} else if (!this.hasGlobalAdminAccess(ctx)) throw new GraphQLError("Forbidden: insufficient permissions to create documents");
 					const result = await createEmptyDocument(this.reactorClient, args);
+					if (result?.id && result.documentType === "powerhouse/document-drive") this.graphqlManager.driveOwnershipCache.add(result.id);
 					if (this.authorizationService && ctx.user?.address && result?.id) await this.documentPermissionService?.initializeDocumentProtection(result.id, ctx.user.address, this.authorizationService.config.defaultProtection);
 					return result;
 				} catch (error) {
@@ -4608,7 +4794,10 @@ var ReactorSubgraph = class extends BaseSubgraph {
 				this.logger.debug("deleteDocument(@args)", args);
 				try {
 					await this.assertCanWrite(args.identifier, ctx);
-					return await deleteDocument(this.reactorClient, args);
+					const driveIdToInvalidate = await this.#resolveDriveId(args.identifier);
+					const result = await deleteDocument(this.reactorClient, args);
+					if (result && driveIdToInvalidate) this.graphqlManager.driveOwnershipCache.remove(driveIdToInvalidate);
+					return result;
 				} catch (error) {
 					this.logger.error("Error in deleteDocument(@args): @Error", error);
 					throw error;
@@ -4713,29 +4902,14 @@ dotenv.config();
 const ADMIN_USERS = getAdminUsers();
 //#endregion
 //#region src/graphql/system/version.ts
-let cachedVersion;
-let cachedGitHash;
 function getVersion() {
-	if (cachedVersion !== void 0) return cachedVersion;
-	cachedVersion = process.env.PH_VERSION ?? process.env.npm_package_version ?? "unknown";
-	return cachedVersion;
+	return "6.0.2-staging.7";
 }
 function getGitHash() {
-	if (cachedGitHash !== void 0) return cachedGitHash;
-	if (process.env.PH_GIT_SHA) {
-		cachedGitHash = process.env.PH_GIT_SHA;
-		return cachedGitHash;
-	}
-	try {
-		cachedGitHash = execSync("git rev-parse HEAD", { stdio: [
-			"ignore",
-			"pipe",
-			"ignore"
-		] }).toString().trim();
-	} catch {
-		cachedGitHash = "unknown";
-	}
-	return cachedGitHash;
+	return "6b981a6f1934d98ad53dde1f68a46d9758d7c962";
+}
+function getGitUrl() {
+	return buildTreeUrl(getGitHash());
 }
 //#endregion
 //#region src/graphql/system/subgraph.ts
@@ -4746,6 +4920,7 @@ var SystemSubgraph = class extends BaseSubgraph {
     type SystemInfo {
       version: String!
       gitHash: String!
+      gitUrl: String
     }
 
     type Query {
@@ -4754,7 +4929,8 @@ var SystemSubgraph = class extends BaseSubgraph {
   `;
 	resolvers = { Query: { system: () => ({
 		version: getVersion(),
-		gitHash: getGitHash()
+		gitHash: getGitHash(),
+		gitUrl: getGitUrl()
 	}) } };
 };
 //#endregion
@@ -5895,102 +6071,6 @@ var DocumentPermissionService = class {
 	}
 };
 //#endregion
-//#region src/tracing.ts
-const TEMPO_ENDPOINT = process.env.TEMPO_ENDPOINT || "http://tempo.monitoring.svc.cluster.local:4318/v1/traces";
-const SERVICE_NAME = process.env.OTEL_SERVICE_NAME || "reactor-api";
-const SERVICE_VERSION = process.env.npm_package_version || "unknown";
-const TENANT_ID = process.env.TENANT_ID || "default";
-const METRICS_ENDPOINT = process.env.METRICS_ENDPOINT;
-const METRICS_EXPORT_INTERVAL_MS = parseInt(process.env.METRICS_EXPORT_INTERVAL_MS || "30000", 10);
-const TRACING_ENABLED = process.env.ENABLE_TRACING === "true" || process.env.NODE_ENV === "production";
-if (TRACING_ENABLED) {
-	console.log(`Initializing OpenTelemetry tracing for ${SERVICE_NAME}...`);
-	console.log(`  Tempo endpoint: ${TEMPO_ENDPOINT}`);
-	console.log(`  Service: ${SERVICE_NAME}`);
-	console.log(`  Tenant: ${TENANT_ID}`);
-	const traceExporter = new OTLPTraceExporter({
-		url: TEMPO_ENDPOINT,
-		headers: {}
-	});
-	const resource = new Resource({
-		[ATTR_SERVICE_NAME]: SERVICE_NAME,
-		[ATTR_SERVICE_VERSION]: SERVICE_VERSION,
-		"tenant.id": TENANT_ID,
-		"deployment.environment": process.env.NODE_ENV || "development"
-	});
-	const PROMETHEUS_METRICS_PORT = process.env.PROMETHEUS_METRICS_PORT;
-	let metricReader;
-	if (PROMETHEUS_METRICS_PORT) {
-		const port = parseInt(PROMETHEUS_METRICS_PORT, 10);
-		metricReader = new PrometheusExporter({
-			port,
-			preventServerStart: false
-		});
-		console.log(`  Prometheus /metrics on port ${port}`);
-	} else if (METRICS_ENDPOINT) {
-		metricReader = new PeriodicExportingMetricReader({
-			exporter: new OTLPMetricExporter({ url: METRICS_ENDPOINT }),
-			exportIntervalMillis: METRICS_EXPORT_INTERVAL_MS
-		});
-		console.log(`  Metrics OTLP endpoint: ${METRICS_ENDPOINT}`);
-		console.log(`  Metrics interval: ${METRICS_EXPORT_INTERVAL_MS}ms`);
-	}
-	const sdk = new NodeSDK({
-		resource,
-		spanProcessors: [new BatchSpanProcessor(traceExporter)],
-		metricReader,
-		instrumentations: [getNodeAutoInstrumentations({
-			"@opentelemetry/instrumentation-http": {
-				enabled: true,
-				ignoreIncomingRequestHook: (req) => {
-					return req.url === "/health" || req.url === "/ready";
-				},
-				requireParentforIncomingSpans: false,
-				requireParentforOutgoingSpans: false,
-				requestHook: (span, request) => {
-					span.setAttribute("http.route", request.url || "");
-				},
-				responseHook: (span, response) => {
-					if (response.statusCode) span.setAttribute("http.status_code", response.statusCode);
-				}
-			},
-			"@opentelemetry/instrumentation-express": {
-				enabled: true,
-				requestHook: (span, info) => {
-					if (info.route) span.setAttribute("http.route", info.route);
-				}
-			},
-			"@opentelemetry/instrumentation-graphql": {
-				enabled: true,
-				mergeItems: true,
-				allowValues: true
-			},
-			"@opentelemetry/instrumentation-pg": {
-				enabled: true,
-				enhancedDatabaseReporting: true
-			},
-			"@opentelemetry/instrumentation-redis-4": {
-				enabled: true,
-				dbStatementSerializer: (cmdName, cmdArgs) => {
-					return cmdName;
-				}
-			}
-		})]
-	});
-	sdk.start();
-	console.log("✓ OpenTelemetry tracing initialized");
-	process.on("SIGTERM", () => {
-		sdk.shutdown().then(() => console.log("Tracing terminated")).catch((error) => console.log("Error terminating tracing", error)).finally(() => process.exit(0));
-	});
-}
-async function initTracing() {}
-function isTracingEnabled() {
-	return TRACING_ENABLED;
-}
-async function trace(_name, _options, fn) {
-	return fn();
-}
-//#endregion
 //#region src/utils/db.ts
 function isPG(connectionString) {
 	if (connectionString.startsWith("postgresql://") || connectionString.startsWith("postgres://")) return true;
@@ -5999,7 +6079,8 @@ function isPG(connectionString) {
 function getDbClient(connectionString = void 0, pgliteFactory) {
 	const isPg = connectionString && isPG(connectionString);
 	const client = isPg ? "pg" : ClientPgLite;
-	const connection = isPg ? { connectionString } : { pglite: pgliteFactory ? pgliteFactory(connectionString) : new PGlite(connectionString) };
+	const pgliteInstance = isPg ? void 0 : pgliteFactory ? pgliteFactory(connectionString) : new PGlite(connectionString);
+	const connection = isPg ? { connectionString } : { pglite: pgliteInstance };
 	if (connectionString && !isPg) {
 		const dirPath = path.resolve(connectionString, "..");
 		if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
@@ -6013,7 +6094,8 @@ function getDbClient(connectionString = void 0, pgliteFactory) {
 			knex: knexInstance,
 			kyselySubDialect: new PGColdDialect()
 		}) }),
-		knex: knexInstance
+		knex: knexInstance,
+		pglite: pgliteInstance
 	};
 }
 const initAnalyticsStoreSql = [
@@ -6086,19 +6168,36 @@ function resolveAttachmentStoragePath(options) {
 	return path.join(tmpdir(), "reactor-attachments");
 }
 /**
-* Initializes the database and analytics store
+* Initializes the database and analytics store. The returned `closers` are
+* idempotent thunks that release the underlying knex pool and PGlite instance
+* (when on-disk PGlite is in use); callers are expected to run them as part
+* of API teardown so PGlite WAL is flushed and the data-dir lock is released.
 */
 async function initializeDatabaseAndAnalytics(dbPath, pgliteFactory) {
-	const { db, knex } = getDbClient(dbPath, pgliteFactory);
+	const { db, knex, pglite } = getDbClient(dbPath, pgliteFactory);
 	const relationalDb = createRelationalDb(db);
 	const analyticsStore = new PostgresAnalyticsStore({ knex });
 	for (const sql of initAnalyticsStoreSql) await knex.raw(sql);
 	return {
 		relationalDb,
-		analyticsStore
+		analyticsStore,
+		closers: makeDbClosers(knex, pglite)
 	};
 }
 /**
+* Builds best-effort closers for a knex/PGlite pair returned by
+* {@link getDbClient}. Order is significant: knex first releases its pool
+* (which is what the application talks to), then PGlite flushes WAL and
+* unlocks the data dir.
+*/
+function makeDbClosers(knexInstance, pglite) {
+	const closers = [() => knexInstance.destroy()];
+	if (pglite) closers.push(async () => {
+		if (!pglite.closed) await pglite.close();
+	});
+	return closers;
+}
+/**
 * Sets up the subgraph manager and registers subgraphs
 */
 async function setupGraphQLManager(httpAdapter, authFetchMiddleware, httpServer, wsServer, client, relationalDb, analyticsStore, syncManager, subgraphs, logger, auth, documentPermissionService, enableDocumentModelSubgraphs, port, authorizationService) {
@@ -6173,7 +6272,6 @@ async function startServer(httpAdapter, port, httpsOptions, logger) {
 * This includes auth configuration, database setup, and package manager initialization.
 */
 async function _setupCommonInfrastructure(options) {
-	if (isTracingEnabled()) await initTracing();
 	const port = options.port ?? DEFAULT_PORT;
 	const { adapter: httpAdapter } = createHttpAdapter("express");
 	let admins = [];
@@ -6216,10 +6314,13 @@ async function _setupCommonInfrastructure(options) {
 		});
 		authFetchMiddleware = createAuthFetchMiddleware(authService);
 	}
-	const { relationalDb, analyticsStore } = await trace("reactor-api.init.database", { tags: { "resource.name": "database" } }, () => initializeDatabaseAndAnalytics(options.dbPath, options.pgliteFactory));
+	const dbClosers = [];
+	const { relationalDb, analyticsStore, closers: analyticsClosers } = await initializeDatabaseAndAnalytics(options.dbPath, options.pgliteFactory);
+	dbClosers.push(...analyticsClosers);
 	let documentPermissionService = options.documentPermissionService;
 	if (!documentPermissionService && DOCUMENT_PERMISSIONS_ENABLED === "true") {
-		const { db } = getDbClient(options.dbPath, options.pgliteFactory);
+		const { db, knex, pglite } = getDbClient(options.dbPath, options.pgliteFactory);
+		dbClosers.push(...makeDbClosers(knex, pglite));
 		await runMigrations(db);
 		logger.info("Document permission migrations completed");
 		documentPermissionService = new DocumentPermissionService(db, { defaultProtection });
@@ -6235,7 +6336,8 @@ async function _setupCommonInfrastructure(options) {
 	}
 	const attachmentStoragePath = resolveAttachmentStoragePath(options);
 	await mkdir(attachmentStoragePath, { recursive: true });
-	const { db: attachmentDb } = getDbClient(options.dbPath, options.pgliteFactory);
+	const { db: attachmentDb, knex: attachmentKnex, pglite: attachmentPglite } = getDbClient(options.dbPath, options.pgliteFactory);
+	dbClosers.push(...makeDbClosers(attachmentKnex, attachmentPglite));
 	const attachments = await new AttachmentBuilder(attachmentDb, attachmentStoragePath).build();
 	logger.info("Attachment service initialized");
 	const packages = new PackageManager(options.packageLoaders ?? [new ImportPackageLoader()], {
@@ -6256,13 +6358,14 @@ async function _setupCommonInfrastructure(options) {
 		documentPermissionService,
 		authorizationService,
 		attachments,
-		packages
+		packages,
+		dbClosers
 	};
 }
 /**
 * Private helper function containing common setup logic for API initialization
 */
-async function _setupAPI(reactorClient, syncManager, reactorProcessorManager, httpAdapter, authFetchMiddleware, authService, port, packages, relationalDb, analyticsStore, documentPermissionService, processors, subgraphs, options, auth, processorApp, readModels, attachments, authorizationService, documentModelRegistry) {
+async function _setupAPI(reactorClient, syncManager, reactorProcessorManager, httpAdapter, authFetchMiddleware, authService, port, packages, relationalDb, analyticsStore, documentPermissionService, processors, subgraphs, options, auth, processorApp, readModels, attachments, authorizationService, documentModelRegistry, dbClosers = []) {
 	const hostModule = {
 		relationalDb,
 		analyticsStore,
@@ -6328,7 +6431,51 @@ async function _setupAPI(reactorClient, syncManager, reactorProcessorManager, ht
 		graphqlManager,
 		packages,
 		attachments,
-		authService
+		authService,
+		dispose: buildApiDispose({
+			graphqlManager,
+			httpServer,
+			wsServer,
+			dbClosers,
+			logger
+		})
+	};
+}
+/**
+* Composes the lifecycle teardown for an API instance. Steps run in
+* dependency order so that draining HTTP/GraphQL surfaces happens before the
+* underlying knex pool and PGlite WAL are released. Each step is wrapped in
+* its own try/catch — one failure must not strand the rest of the chain,
+* since this runs on the way to process exit.
+*/
+function buildApiDispose(args) {
+	const { graphqlManager, httpServer, wsServer, dbClosers, logger } = args;
+	let disposed = false;
+	return async () => {
+		if (disposed) return;
+		disposed = true;
+		try {
+			await graphqlManager.shutdown();
+		} catch (error) {
+			logger.error("API dispose: graphqlManager.shutdown failed:", error);
+		}
+		try {
+			for (const client of wsServer.clients) client.terminate();
+			await new Promise((resolve) => wsServer.close(() => resolve()));
+		} catch (error) {
+			logger.error("API dispose: wsServer.close failed:", error);
+		}
+		if (httpServer.listening) try {
+			httpServer.closeAllConnections();
+			await new Promise((resolve, reject) => httpServer.close((err) => err ? reject(err) : resolve()));
+		} catch (error) {
+			logger.error("API dispose: httpServer.close failed:", error);
+		}
+		for (const close of dbClosers) try {
+			await close();
+		} catch (error) {
+			logger.error("API dispose: db closer failed:", error);
+		}
 	};
 }
 /**
@@ -6342,9 +6489,9 @@ async function _setupAPI(reactorClient, syncManager, reactorProcessorManager, ht
 * @returns The API server components along with the created client instances.
 */
 async function initializeAndStartAPI(clientInitializer, options, processorApp) {
-	const { port, httpAdapter, authFetchMiddleware, authService, auth, relationalDb, analyticsStore, documentPermissionService, authorizationService, attachments, packages } = await trace("reactor-api.setup.infrastructure", { tags: { "resource.name": "infrastructure" } }, () => _setupCommonInfrastructure(options));
-	const { documentModels, processors, subgraphs } = await trace("reactor-api.packages.init", { tags: { "resource.name": "packages" } }, () => packages.init());
-	const reactorClientModule = await trace("reactor-api.reactor-client.init", { tags: { "resource.name": "reactor-client" } }, () => clientInitializer(documentModels));
+	const { port, httpAdapter, authFetchMiddleware, authService, auth, relationalDb, analyticsStore, documentPermissionService, authorizationService, attachments, packages, dbClosers } = await _setupCommonInfrastructure(options);
+	const { documentModels, processors, subgraphs } = await packages.init();
+	const reactorClientModule = await clientInitializer(documentModels);
 	const reactorClient = reactorClientModule.client;
 	const syncManager = reactorClientModule.reactorModule?.syncModule?.syncManager;
 	if (!syncManager) throw new Error("SyncManager not available from ReactorClientModule");
@@ -6353,7 +6500,7 @@ async function initializeAndStartAPI(clientInitializer, options, processorApp) {
 	const documentModelRegistry = reactorClientModule.reactorModule?.documentModelRegistry;
 	if (!documentModelRegistry) throw new Error("DocumentModelRegistry not available from ReactorClientModule");
 	return {
-		...await _setupAPI(reactorClient, syncManager, reactorProcessorManager, httpAdapter, authFetchMiddleware, authService, port, packages, relationalDb, analyticsStore, documentPermissionService, processors, subgraphs, options, auth, processorApp, (reactorClientModule.reactorModule?.readModelCoordinator)?.readModels ?? [], attachments, authorizationService, documentModelRegistry),
+		...await _setupAPI(reactorClient, syncManager, reactorProcessorManager, httpAdapter, authFetchMiddleware, authService, port, packages, relationalDb, analyticsStore, documentPermissionService, processors, subgraphs, options, auth, processorApp, (reactorClientModule.reactorModule?.readModelCoordinator)?.readModels ?? [], attachments, authorizationService, documentModelRegistry, dbClosers),
 		client: reactorClient,
 		syncManager,
 		documentModelRegistry
@@ -6459,6 +6606,7 @@ var PackageManagementService = class {
 	}
 };
 //#endregion
-export { ADMIN_USERS, ActionContextInputSchema, ActionInputSchema, AddRelationshipDocument, AnalyticsSubgraph, AttachmentInputSchema, AuthService, AuthSubgraph, BaseSubgraph, ChannelMetaInputSchema, CreateDocumentDocument, CreateEmptyDocumentDocument, DeleteDocumentDocument, DeleteDocumentsDocument, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentOperationsFilterInputSchema, DocumentPermissionService, FindDocumentsDocument, GetDocumentDocument, GetDocumentIncomingRelationshipsDocument, GetDocumentModelsDocument, GetDocumentOperationsDocument, GetDocumentOutgoingRelationshipsDocument, GetDocumentWithOperationsDocument, GetJobStatusDocument, GraphQLManager, HttpDocumentModelLoader, HttpPackageLoader, ImportPackageLoader, InMemoryPackageStorage, JobChangesDocument, MoveRelationshipDocument, MutateDocumentAsyncDocument, MutateDocumentDocument, OperationContextInputSchema, OperationInputSchema, OperationWithContextInputSchema, OperationsFilterInputSchema, PackageManagementService, PackageManager, PackagesSubgraph, PagingInputSchema, PhDocumentFieldsFragmentDoc, PollSyncEnvelopesDocument, PropagationMode, PropagationModeSchema, PushSyncEnvelopesDocument, ReactorSignerAppInputSchema, ReactorSignerInputSchema, ReactorSignerUserInputSchema, ReactorSubgraph, RemoteCursorInputSchema, RemoteFilterInputSchema, RemoveRelationshipDocument, RenameDocumentDocument, SearchFilterInputSchema, SyncEnvelopeInputSchema, SyncEnvelopeType, SyncEnvelopeTypeSchema, SystemSubgraph, TouchChannelDocument, TouchChannelInputSchema, ViewFilterInputSchema, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, createAuthFetchMiddleware, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createSchema, definedNonNullAnySchema, driveIdFromUrl, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getGitHash, getSdk, getUniqueDocumentModels, getVersion, initAnalyticsStoreSql, initTracing, initializeAndStartAPI, isDefinedNonNullAny, isSubgraphClass, isTracingEnabled, parseDriveUrl, renderGraphqlPlayground, trace };
+export { ADMIN_USERS, ActionContextInputSchema, ActionInputSchema, AddRelationshipDocument, AnalyticsSubgraph, AttachmentInputSchema, AuthService, AuthSubgraph, BaseSubgraph, ChannelMetaInputSchema, CreateDocumentDocument, CreateEmptyDocumentDocument, DeleteDocumentDocument, DeleteDocumentsDocument, DocumentChangeType, DocumentChangeTypeSchema, DocumentChangesDocument, DocumentOperationsFilterInputSchema, DocumentPermissionService, FindDocumentsDocument, GetDocumentDocument, GetDocumentIncomingRelationshipsDocument, GetDocumentModelsDocument, GetDocumentOperationsDocument, GetDocumentOutgoingRelationshipsDocument, GetDocumentWithOperationsDocument, GetJobStatusDocument, GraphQLManager, HttpDocumentModelLoader, HttpPackageLoader, ImportPackageLoader, InMemoryPackageStorage, JobChangesDocument, MoveRelationshipDocument, MutateDocumentAsyncDocument, MutateDocumentDocument, OperationContextInputSchema, OperationInputSchema, OperationWithContextInputSchema, OperationsFilterInputSchema, PackageManagementService, PackageManager, PackagesSubgraph, PagingInputSchema, PhDocumentFieldsFragmentDoc, PollSyncEnvelopesDocument, PropagationMode, PropagationModeSchema, PushSyncEnvelopesDocument, ReactorSignerAppInputSchema, ReactorSignerInputSchema, ReactorSignerUserInputSchema, ReactorSubgraph, RemoteCursorInputSchema, RemoteFilterInputSchema, RemoveRelationshipDocument, RenameDocumentDocument, SearchFilterInputSchema, SyncEnvelopeInputSchema, SyncEnvelopeType, SyncEnvelopeTypeSchema, SystemSubgraph, TouchChannelDocument, TouchChannelInputSchema, ViewFilterInputSchema, buildGraphQlDocument, buildGraphQlDriveDocument, buildGraphqlOperation, buildGraphqlOperations, buildSubgraphSchemaModule, createAuthFetchMiddleware, createGatewayAdapter, createHttpAdapter, createMergedSchema, createReactorGraphQLClient, createSchema, definedNonNullAnySchema, driveIdFromUrl, generateDocumentModelSchema, getAuthContext, getDbClient, getDocumentModelSchemaName, getDocumentModelTypeDefs, getGitHash, getGitUrl, getSdk, getUniqueDocumentModels, getVersion, initAnalyticsStoreSql, initializeAndStartAPI, isDefinedNonNullAny, isSubgraphClass, parseDriveUrl, renderGraphqlPlayground };
 
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map
+//# debugId=81df4612-dfa1-5785-acec-bca9f4770f2d