@powerhousedao/reactor-api 6.2.3-dev.5 → 6.2.3-dev.51

package/dist/src/pglite/pglite-node.d.mts

@@ -0,0 +1,130 @@
+import { ILogger } from "document-model";
+import nodeFs from "node:fs";
+import { PGlite } from "@electric-sql/pglite";
+import { NodeFS } from "@electric-sql/pglite/nodefs";
+//#region src/pglite/maintenance.d.ts
+export declare const DEFAULT_MAINTENANCE_INTERVAL_MS: number;
+export declare const DEFAULT_VACUUM_FULL_ABOVE_BYTES: number;
+type MaintenanceOutcome = "vacuum" | "vacuum-full" | "idle" | "not-ready" | "in-transaction" | "failed";
+interface MaintenanceLogger {
+  warn(message: string): void;
+}
+interface MaintenanceOptions {
+  /** VACUUM + CHECKPOINT cadence; PGlite has no autovacuum. Default 5 min; 0 disables. */
+  intervalMs?: number;
+  /** First pass runs VACUUM FULL when `base/` exceeds this at open. Default 256 MB; 0 disables. */
+  vacuumFullAboveBytes?: number;
+  logger?: MaintenanceLogger;
+}
+export declare class PgliteMaintenance {
+  private readonly intervalMs;
+  private readonly vacuumFullAboveBytes;
+  private readonly logger?;
+  private pg?;
+  private label;
+  private closing;
+  private syncsSinceMaintenance;
+  private vacuumFullPending;
+  private timer?;
+  private inFlight?;
+  constructor(options?: MaintenanceOptions);
+  get scheduled(): boolean;
+  get running(): boolean;
+  start(pg: PGlite, label: string, baseBytes: number): void;
+  noteSync(): void;
+  stop(): Promise<void>;
+  run(): Promise<MaintenanceOutcome>;
+  private schedule;
+  private cancel;
+}
+//#endregion
+//#region src/pglite/durable-node-fs.d.ts
+type NodeFsClass = typeof NodeFS;
+interface DurableNodeFsOptions {
+  /** Default true; `PH_PGLITE_FSYNC=0` turns it off (power-loss durability off). */
+  fsync?: boolean;
+  /** Default 5 min; 0 disables. */
+  maintenanceIntervalMs?: number;
+  /** `base/` size at open; default 256 MB; 0 disables. */
+  vacuumFullAboveBytes?: number;
+  logger?: {
+    warn(message: string): void;
+  };
+  /** Emscripten abort (a Postgres PANIC, e.g. ENOSPC on WAL). */
+  onAbort?: (what: unknown) => void;
+  hostFs?: Pick<typeof nodeFs, "fsyncSync" | "fdatasyncSync">;
+}
+type DurableNodeFs = InstanceType<NodeFsClass> & {
+  readonly maintenance: PgliteMaintenance;
+};
+export declare function resolvePgliteFsync(env: Record<string, string | undefined>): boolean;
+/** Built over the passed-in class so PG16 dirs on `pglite-legacy-02` get the same behaviour. */
+export declare function createDurableNodeFs(Base: NodeFsClass, dataDir: string, options?: DurableNodeFsOptions): DurableNodeFs;
+//#endregion
+//#region src/pglite/sync-tree.d.ts
+interface SyncTreeHostFs {
+  fsyncSync(fd: number): void;
+}
+interface SyncTreeResult {
+  files: number;
+  dirs: number;
+}
+/** One pass over a finished tree; interleaving fsync with writes costs seconds. */
+export declare function syncTree(root: string, hostFs?: SyncTreeHostFs): SyncTreeResult;
+/** fsyncs a directory's entries; false where the platform refuses (Windows). */
+export declare function syncDirectory(dir: string, hostFs?: SyncTreeHostFs): boolean;
+//#endregion
+//#region src/pglite/snapshot-reader.d.ts
+export declare const SNAPSHOT_FILE_NAME = "snapshot.bin";
+interface ExtractSnapshotOptions {
+  chunkSize?: number;
+  /** Default true: one fsync pass over the tree after the last write. */
+  sync?: boolean;
+  hostFs?: SyncTreeHostFs;
+}
+interface ExtractedSnapshot {
+  pgVersionMajor: number;
+  /** `global/pg_control` bytes; absent only in synthetic trees. */
+  pgControl?: Buffer;
+  /** Entries written to disk; skipped entries are not counted. */
+  entries: number;
+  /** Size of the snapshot file. */
+  bytes: number;
+}
+/** Unpacks a snapshot into the existing `outDir`. */
+export declare function extractSnapshot(snapshotPath: string, outDir: string, options?: ExtractSnapshotOptions): Promise<ExtractedSnapshot>;
+//#endregion
+//#region src/pglite/convert-snapshot-dir.d.ts
+interface VerifyHandle {
+  query<T>(sql: string): Promise<{
+    rows: T[];
+  }>;
+  close(): Promise<void>;
+}
+type ConversionStep = "extract" | "verify" | "renameOld" | "renameNew" | "removeOld";
+interface ConversionDeps {
+  /** Opens `dataDir` with the stock NodeFS of the PGlite module for `major`. */
+  openForVerify: (major: number, dataDir: string) => Promise<VerifyHandle>;
+  logger: ILogger;
+  /** Test hook: throw after a named step to simulate a crash there. */
+  afterStep?: (step: ConversionStep) => void | Promise<void>;
+  hostFs?: SyncTreeHostFs;
+}
+/** Settles the debris of an interrupted conversion; runs before it at boot. */
+export declare function recoverConversion(dir: string, deps: ConversionDeps): Promise<void>;
+/** Extracts into `.converting`, verifies by opening it, swaps through `.old`. */
+export declare function convertSnapshotDir(dir: string, deps: ConversionDeps): Promise<"converted" | "none">;
+//#endregion
+//#region src/pglite/preflight.d.ts
+/** PG major of the pinned @electric-sql/pglite; it exports none, so the test checks initdb. */
+export declare const CURRENT_PGLITE_MAJOR = 17;
+/** `openForVerify` over the loaded PGlite module only. */
+export declare function openCurrentPgliteForVerify(major: number, dataDir: string): Promise<VerifyHandle>;
+/** Converts a snapshot store and clears the files a previous run leaves behind. */
+export declare function preparePgliteDataDir(dir: string, deps: ConversionDeps): Promise<void>;
+/** PGlite leaves `postmaster.pid` after every close and `pg_wal/xlogtemp.*` after some. */
+export declare function removeStalePgliteFiles(dir: string, logger: Pick<ILogger, "debug">): Promise<void>;
+//#endregion
+export type { ConversionDeps, ConversionStep, DurableNodeFs, DurableNodeFsOptions, ExtractSnapshotOptions, ExtractedSnapshot, MaintenanceLogger, MaintenanceOptions, MaintenanceOutcome, NodeFsClass, SyncTreeHostFs, SyncTreeResult, VerifyHandle };
+export {};
+//# sourceMappingURL=pglite-node.d.mts.map

package/dist/src/pglite/pglite-node.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pglite-node.d.mts","names":[],"sources":["../../../src/pglite/maintenance.ts","../../../src/pglite/durable-node-fs.ts","../../../src/pglite/sync-tree.ts","../../../src/pglite/snapshot-reader.ts","../../../src/pglite/convert-snapshot-dir.ts","../../../src/pglite/preflight.ts"],"mappings":";;;;;qBAIa;qBACA;KAGD;UAQK;EACf,KAAK;;UAGU;;EAEf;;EAEA;EACA,SAAS;;qBAGE;mBACM;mBACA;mBACA;UAET;UACA;UACA;UACA;UACA;UACA;UACA;EAER,YAAY,UAAS;MAYjB;MAIA;EAIJ,MAAM,IAAI,QAAQ,eAAe;EAQjC;EAIM,QAAQ;EAMR,OAAO,QAAQ;UA+Cb;UAoBA;;;;KC1IE,qBAAqB;UAKhB;;EAEf;;EAEA;;EAEA;EACA;IAAW,KAAK;;;EAEhB,WAAW;EACX,SAAS,YAAY;;KAGX,gBAAgB,aAAa;WAC9B,aAAa;;wBAGR,mBACd,KAAK;;wBAmES,oBACd,MAAM,aACN,iBACA,UAAS,uBACR;;;UCnGc;EACf,UAAU;;UAGK;EACf;EACA;;;wBAIc,SACd,cACA,SAAQ,iBACP;;wBA+Ba,cACd,aACA,SAAQ;;;qBC3CG;UASI;EACf;;EAEA;EACA,SAAS;;UAGM;EACf;;EAEA,YAAY;;EAEZ;;EAEA;;;wBAIoB,gBACpB,sBACA,gBACA,UAAS,yBACR,QAAQ;;;UC/BM;EACf,MAAM,GAAG,cAAc;IAAU,MAAM;;EACvC,SAAS;;KAGC;UAOK;;EAEf,gBAAgB,eAAe,oBAAoB,QAAQ;EAC3D,QAAQ;;EAER,aAAa,MAAM,0BAA0B;EAC7C,SAAS;;;wBA6BW,kBACpB,aACA,MAAM,iBACL;;wBA6CmB,mBACpB,aACA,MAAM,iBACL;;;;qBC3FU;;wBAGS,2BACpB,eACA,kBACC,QAAQ;;wBAYW,qBACpB,aACA,MAAM,iBACL;;wBAOmB,uBACpB,aACA,QAAQ,KAAK,oBACZ"}

package/dist/src/pglite/pglite-node.mjs

@@ -0,0 +1,4 @@
+import { a as convertSnapshotDir, c as extractSnapshot, d as syncDirectory, f as syncTree, h as PgliteMaintenance, i as removeStalePgliteFiles, l as createDurableNodeFs, m as DEFAULT_VACUUM_FULL_ABOVE_BYTES, n as openCurrentPgliteForVerify, o as recoverConversion, p as DEFAULT_MAINTENANCE_INTERVAL_MS, r as preparePgliteDataDir, s as SNAPSHOT_FILE_NAME, t as CURRENT_PGLITE_MAJOR, u as resolvePgliteFsync } from "../../pglite-node-Ow9i5Rb4.mjs";
+export { CURRENT_PGLITE_MAJOR, DEFAULT_MAINTENANCE_INTERVAL_MS, DEFAULT_VACUUM_FULL_ABOVE_BYTES, PgliteMaintenance, SNAPSHOT_FILE_NAME, convertSnapshotDir, createDurableNodeFs, extractSnapshot, openCurrentPgliteForVerify, preparePgliteDataDir, recoverConversion, removeStalePgliteFiles, resolvePgliteFsync, syncDirectory, syncTree };
+!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]="6dd4c09b-2fd7-5402-83f6-a92c933064b1")}catch(e){}}();
+//# debugId=6dd4c09b-2fd7-5402-83f6-a92c933064b1

package/dist/{utils-XWVecaNn.mjs → subgraph-extraction-sQlZLLPH.mjs}

@@ -1,11 +1,15 @@
 
-!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]="df700b05-17ec-5ac9-b31f-f6f9cfcfa5f5")}catch(e){}}();
+!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]="a7006388-c7a4-51a6-82d1-b4ec96082701")}catch(e){}}();
+import { createRequire } from "node:module";
 import { gql } from "graphql-tag";
 import { GraphQLError } from "graphql";
 import { DRIVE_AUTH_ERROR_MESSAGES, RECOVERABLE_GRAPHQL_ERROR_CODES } from "@powerhousedao/reactor";
+import { PURGE_DOCUMENT } from "@powerhousedao/shared/document-model";
 import { childLogger } from "document-model";
-import path from "node:path";
+import path, { dirname, isAbsolute, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { packageJsonExports } from "@powerhousedao/shared/clis/constants";
 //#region src/graphql/errors.ts
 /** Caller (authenticated or anonymous) lacks permission for the document. */
 var ForbiddenError = class extends GraphQLError {
@@ -60,6 +64,18 @@ var MalformedStoredOperationError = class extends GraphQLError {
 		super(`Stored operation cannot be served: ${detail}`, { extensions: { code: RECOVERABLE_GRAPHQL_ERROR_CODES.malformedStoredOperation } });
 	}
 };
+/**
+* The marker refusals a poll carried were not recorded, so the poll fails.
+* The code is recoverable: the client keeps polling and reports them again.
+*/
+var RefusalNotRecordedError = class extends GraphQLError {
+	constructor(cause) {
+		super("A reported marker refusal was not recorded; report it again", {
+			originalError: cause instanceof Error ? cause : new Error(String(cause)),
+			extensions: { code: RECOVERABLE_GRAPHQL_ERROR_CODES.refusalNotRecorded }
+		});
+	}
+};
 //#endregion
 //#region src/services/authorization.service.ts
 /**
@@ -68,6 +84,8 @@ var MalformedStoredOperationError = class extends GraphQLError {
 * identifier when the check was skipped for a policy-wide caller.
 */
 var AuthorizedDocumentHandle = class AuthorizedDocumentHandle {
+	fetchIdentifier;
+	isResolved;
 	constructor(fetchIdentifier, isResolved) {
 		this.fetchIdentifier = fetchIdentifier;
 		this.isResolved = isResolved;
@@ -91,6 +109,7 @@ const AuthorizationPolicy = {
 };
 /** Shared config holder and admin-list check for the policy strategies. */
 var BaseAuthorizationService = class {
+	config;
 	constructor(config) {
 		this.config = config;
 	}
@@ -174,6 +193,7 @@ var DocumentPermissionsAuthorizationService = class extends BaseAuthorizationSer
 	}
 	async canMutate(documentId, operationType, userAddress) {
 		if (this.isSupremeAdmin(userAddress)) return true;
+		if (operationType === PURGE_DOCUMENT) return this.#isDocumentAdmin(documentId, userAddress);
 		if (await this.#permissions.isOperationRestricted(documentId, operationType)) {
 			if (!userAddress) return false;
 			if (await this.#isDocumentAdmin(documentId, userAddress)) return true;
@@ -268,6 +288,16 @@ function createCanonicalDocumentIdResolver(client) {
 }
 //#endregion
 //#region src/graphql/base-subgraph.ts
+/**
+* The subject a request reads as: its address and the app key its token
+* carries. Anonymous is an empty subject, never the host's signer.
+*/
+function callerSubject(user) {
+	return {
+		address: user?.address,
+		key: user?.appKey
+	};
+}
 var BaseSubgraph = class {
 	name = "example";
 	path = "";
@@ -293,6 +323,8 @@ var BaseSubgraph = class {
 	*/
 	#canonicalIdMemo = /* @__PURE__ */ new WeakMap();
 	#resolveCanonical;
+	#attachments;
+	#attachmentClientMemo = /* @__PURE__ */ new WeakMap();
 	constructor(args) {
 		this.#resolveCanonical = createCanonicalDocumentIdResolver(args.reactorClient);
 		this.http = args.http;
@@ -304,6 +336,21 @@ var BaseSubgraph = class {
 		this.authorizationService = args.authorizationService;
 		this.syncServingGate = args.syncServingGate;
 		this.path = args.path ?? "";
+		this.#attachments = args.attachments;
+	}
+	/**
+	* An attachment client bound to this request's caller, memoized per request.
+	*
+	* @throws Error when the host provides no attachment client to subgraphs.
+	*/
+	attachmentsFor(ctx) {
+		if (!this.#attachments) throw new Error("This host provides no attachment client to subgraphs");
+		let client = this.#attachmentClientMemo.get(ctx);
+		if (!client) {
+			client = this.#attachments.forSubject(callerSubject(ctx.user));
+			this.#attachmentClientMemo.set(ctx, client);
+		}
+		return client;
 	}
 	async onSetup() {}
 	async onDisconnect() {}
@@ -361,6 +408,13 @@ var BaseSubgraph = class {
 	async canReadDocument(documentId, ctx) {
 		return this.authorizationService.canRead(documentId, ctx.user?.address);
 	}
+	/** Drops the items the host's own ACL refuses the caller. */
+	async readableByHost(items, ctx) {
+		if (this.authorizationService.isSupremeAdmin(ctx.user?.address)) return [...items];
+		const readable = [];
+		for (const item of items) if (await this.canReadDocument(item.id, ctx)) readable.push(item);
+		return readable;
+	}
 	/**
 	* The principal a request decides as: the authenticated caller's address, and
 	* the did:key of the app instance whose token authenticated it.
@@ -372,10 +426,33 @@ var BaseSubgraph = class {
 	* carries the same key. Anonymous callers supply neither.
 	*/
 	viewSubject(ctx) {
-		return {
-			address: ctx.user?.address,
-			key: ctx.user?.appKey
-		};
+		return callerSubject(ctx.user);
+	}
+	/** Whether a listing would serve the document to the caller; fails closed. */
+	async servesDocument(documentId, ctx) {
+		if (!documentId) return false;
+		try {
+			return await this.servesDocumentOrThrows(documentId, ctx);
+		} catch {
+			return false;
+		}
+	}
+	/** {@link servesDocument}, but a reactor that cannot answer throws. */
+	servesDocumentOrThrows(identifier, ctx, view) {
+		return this.reactorClient.isServed(identifier, {
+			...view,
+			subject: this.viewSubject(ctx)
+		});
+	}
+	/**
+	* Whether a listing would serve the document to the caller: the reactor read
+	* gate, then the host's legacy layer, as `findDocuments` applies them. Absent
+	* or withheld is `false`; a failure to decide throws.
+	*/
+	async listsDocument(identifier, ctx, view) {
+		if (!await this.servesDocumentOrThrows(identifier, ctx, view)) return false;
+		if (this.authorizationService.isSupremeAdmin(ctx.user?.address)) return true;
+		return this.canReadDocument(await this.resolveCanonicalDocumentId(identifier, ctx), ctx);
 	}
 	/**
 	* Asserts read access, resolving a slug first. Returns a handle whose
@@ -555,6 +632,30 @@ async function loadDependency(packageName, subPath) {
 		throw e;
 	}
 }
+/**
+* The subgraphs a package's `powerhouse.manifest.json` declares, when the
+* manifest is reachable — which it is for a package identified by an
+* absolute path (how every local project reaches the loaders). Lets the
+* package manager warn when a manifest promises subgraphs and the loaders
+* deliver none, instead of failing silently. For a bare package name the
+* manifest would have to be resolved through the module system; until a
+* caller needs that, a bare name answers [] rather than guessing.
+*/
+function manifestDeclaredSubgraphs(identifier) {
+	if (!path.isAbsolute(identifier)) return [];
+	try {
+		const raw = readFileSync(path.join(identifier, "powerhouse.manifest.json"), "utf-8");
+		const manifest = JSON.parse(raw);
+		if (!Array.isArray(manifest.subgraphs)) return [];
+		return manifest.subgraphs.map((subgraph) => {
+			if (typeof subgraph !== "object" || subgraph === null) return;
+			const { id, name } = subgraph;
+			return id ?? name;
+		}).filter((value) => typeof value === "string" && value.length > 0);
+	} catch {
+		return [];
+	}
+}
 function isUpgradeManifest(value) {
 	return typeof value === "object" && value !== null && "documentType" in value && "supportedVersions" in value && "upgrades" in value;
 }
@@ -593,8 +694,9 @@ function isSubpath(parent, dir) {
 function isSubgraphClass(candidate) {
 	if (typeof candidate !== "function") return false;
 	let proto = Object.getPrototypeOf(candidate);
-	while (proto) {
-		if (Object.prototype.isPrototypeOf.call(proto, BaseSubgraph)) return true;
+	while (typeof proto === "function") {
+		if (proto === BaseSubgraph) return true;
+		if (proto.name === "BaseSubgraph") return true;
 		proto = Object.getPrototypeOf(proto);
 	}
 	return false;
@@ -647,7 +749,184 @@ function buildGraphQlDriveDocument(doc) {
 	};
 }
 //#endregion
-export { createAuthorizationService as _, isSubgraphClass as a, MalformedStoredOperationError as b, isSubpath as c, loadSubgraphs as d, BaseSubgraph as f, AuthorizedDocumentHandle as g, AuthorizationPolicy as h, buildGraphqlOperations as i, loadDocumentModels as l, createCanonicalDocumentIdResolver as m, buildGraphQlDriveDocument as n, debounce as o, CanonicalDocumentIdResolutionError as p, buildGraphqlOperation as r, extractUpgradeManifests as s, buildGraphQlDocument as t, loadProcessors as u, AuthEvaluationUnsupportedError as v, ForbiddenError as y };
+//#region src/packages/document-model-detection.ts
+/**
+* The one acceptance rule for a package's `document-models` module.
+*
+* The three package loaders duck-typed this independently and disagreed on
+* one case: the http loader required `documentModel` to be non-null, while
+* the import and vite loaders accepted any object merely carrying the key,
+* so an export shaped `{ documentModel: null }` registered as a model under
+* two loaders and vanished under the third. The strict rule is the correct
+* one — a module without its documentModel cannot define a document type —
+* and this predicate is now the single rule all three share, the same way
+* extractSubgraphs unified the subgraph rule.
+*/
+function isDocumentModelModule(candidate) {
+	if (candidate === null || typeof candidate !== "object") return false;
+	if (!("documentModel" in candidate)) return false;
+	const model = candidate.documentModel;
+	return model !== null && model !== void 0;
+}
+/** Collects the document-model modules among a namespace's exports. */
+function extractDocumentModels(namespace) {
+	return Object.values(namespace).filter(isDocumentModelModule);
+}
+//#endregion
+//#region src/packages/pieces.ts
+/** The sub-entry every loader asks a package for its pieces through. */
+const PIECES_SUBPATH = "pieces";
+const BUILT_PIECE_LIST = packageJsonExports["./pieces"].node;
+/** Where a package keeps its piece sources, for telling unbuilt from absent. */
+const PIECE_SOURCE_LIST = join(PIECES_SUBPATH, "index.ts");
+/** The nearest enclosing package.json, which `exports` usually hides. */
+function packageRootOf(dir) {
+	let current = dir;
+	while (!existsSync(join(current, "package.json"))) {
+		const parent = dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+	return current;
+}
+function resolvePieceList(specifier, hostDir) {
+	try {
+		return fileURLToPath(import.meta.resolve(specifier));
+	} catch (error) {
+		try {
+			return createRequire(join(hostDir, "package.json")).resolve(specifier);
+		} catch {
+			throw error;
+		}
+	}
+}
+function pieceListLocation(identifier, hostDir = process.cwd()) {
+	if (isAbsolute(identifier)) return {
+		root: identifier,
+		listPath: join(identifier, BUILT_PIECE_LIST)
+	};
+	const listPath = resolvePieceList(`${identifier}/${PIECES_SUBPATH}`, hostDir);
+	const root = packageRootOf(dirname(listPath));
+	if (!root) throw new Error(`No package.json above ${listPath}`);
+	return {
+		root,
+		listPath
+	};
+}
+function packageVersionAt(root) {
+	try {
+		const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+		return typeof pkg.version === "string" && pkg.version !== "" ? pkg.version : void 0;
+	} catch {
+		return;
+	}
+}
+function locatePieces(declared, context) {
+	const { root, identifier, logger, version } = context;
+	const located = [];
+	for (const piece of declared) {
+		const where = piece.entry ?? piece.bundle;
+		if (typeof where !== "string" || where === "") {
+			logger.warn("Piece @piece of @pkg declares neither a bundle nor an entry", piece.name, identifier);
+			continue;
+		}
+		const path = isAbsolute(where) ? where : join(root, where);
+		if (!(piece.entry ? existsSync(path) : existsSync(join(path, "package.json")))) {
+			logger.warn("Piece @piece of @pkg is declared but not built at @path", piece.name, identifier, path);
+			continue;
+		}
+		located.push({
+			name: piece.name,
+			version,
+			...piece.entry ? { entryPath: path } : { bundleDir: path }
+		});
+	}
+	return located;
+}
+function declaredPieces(module, identifier, logger) {
+	const namespace = module ?? {};
+	const declared = namespace.pieces ?? namespace.default;
+	if (!Array.isArray(declared)) {
+		logger.warn("The pieces list of @pkg exports no \"pieces\" array; it contributes none", identifier);
+		return;
+	}
+	return declared;
+}
+function piecesFromCdnList(module, baseUrl, identifier, logger, version) {
+	const declared = declaredPieces(module, identifier, logger);
+	if (!declared) return [];
+	const located = [];
+	for (const piece of declared) {
+		const where = piece.entry ?? piece.bundle;
+		if (typeof where !== "string" || where === "") {
+			logger.warn("Piece @piece of @pkg declares neither a bundle nor an entry", piece.name, identifier);
+			continue;
+		}
+		located.push({
+			name: piece.name,
+			version,
+			entryUrl: `${baseUrl}${where.replace(/^dist\/node\/pieces\//, "")}`
+		});
+	}
+	return located;
+}
+function piecesFromListModule(module, context) {
+	const namespace = module ?? {};
+	const declared = namespace.pieces ?? namespace.default;
+	if (!Array.isArray(declared)) {
+		context.logger.warn("The pieces list of @pkg exports no \"pieces\" array; it contributes none", context.identifier);
+		return [];
+	}
+	const version = packageVersionAt(context.root);
+	if (!version) {
+		context.logger.warn("@pkg has no version in @root/package.json, and a piece takes its package's version; its pieces contribute none", context.identifier, context.root);
+		return [];
+	}
+	return locatePieces(declared, {
+		...context,
+		version
+	});
+}
+//#endregion
+//#region src/packages/subgraph-extraction.ts
+/**
+* The one acceptance rule for a package's `subgraphs` module.
+*
+* All three package loaders (vite, import, http) consume the same generated
+* `subgraphs/index` file, and each used to apply its own rule — the vite
+* loader required a namespace whose alias equalled the class name inside it,
+* the http loader took any function one level deep, and the import loader
+* took every nested value. An export that registered under one loader could
+* silently vanish under another (the codegen-does-not-register-subgraphs
+* report). This is now the single rule they all share:
+*
+* - an export that is itself a subgraph class is accepted (named or default
+*   export of the class);
+* - any subgraph class among the values of an exported object is accepted
+*   (a `export * as Alias from ...` namespace under any alias, or a
+*   default-exported object of classes);
+* - everything else — constants, configs, functions and classes that do not
+*   extend BaseSubgraph — is dropped.
+*
+* Codegen emits `export * as <ClassName> from "./<dir>/index.js"`
+* (makeSubgraphsIndexFile in packages/codegen), which the namespace branch
+* accepts regardless of the alias; hand-written packages may re-export a
+* class directly, which the direct branch accepts. A class reached through
+* both branches is returned once.
+*/
+function extractSubgraphs(namespace) {
+	const found = [];
+	const add = (candidate) => {
+		if (isSubgraphClass(candidate) && !found.includes(candidate)) found.push(candidate);
+	};
+	for (const value of Object.values(namespace)) {
+		add(value);
+		if (value !== null && typeof value === "object") for (const inner of Object.values(value)) add(inner);
+	}
+	return found;
+}
+//#endregion
+export { AuthenticationRequiredError as A, callerSubject as C, AuthorizedDocumentHandle as D, AuthorizationPolicy as E, MalformedStoredOperationError as M, RefusalNotRecordedError as N, createAuthorizationService as O, BaseSubgraph as S, createCanonicalDocumentIdResolver as T, isSubpath as _, packageRootOf as a, loadSubgraphs as b, piecesFromListModule as c, buildGraphQlDriveDocument as d, buildGraphqlOperation as f, extractUpgradeManifests as g, debounce as h, PIECE_SOURCE_LIST as i, ForbiddenError as j, AuthEvaluationUnsupportedError as k, extractDocumentModels as l, isSubgraphClass as m, BUILT_PIECE_LIST as n, pieceListLocation as o, buildGraphqlOperations as p, PIECES_SUBPATH as r, piecesFromCdnList as s, extractSubgraphs as t, buildGraphQlDocument as u, loadDocumentModels as v, CanonicalDocumentIdResolutionError as w, manifestDeclaredSubgraphs as x, loadProcessors as y };
 
-//# sourceMappingURL=utils-XWVecaNn.mjs.map
-//# debugId=df700b05-17ec-5ac9-b31f-f6f9cfcfa5f5
+//# sourceMappingURL=subgraph-extraction-sQlZLLPH.mjs.map
+//# debugId=a7006388-c7a4-51a6-82d1-b4ec96082701