@powerhousedao/reactor-api 6.2.3-dev.9 → 6.2.3-dev.91
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -2
- package/dist/{adapter-gateway-apollo-CxJNBVyD.mjs → adapter-gateway-apollo-D-EdZ4e-.mjs} +23 -23
- package/dist/adapter-gateway-apollo-D-EdZ4e-.mjs.map +1 -0
- package/dist/{adapter-gateway-mercurius-CZVy88Za.mjs → adapter-gateway-mercurius-CdxLge5p.mjs} +4 -12
- package/dist/adapter-gateway-mercurius-CdxLge5p.mjs.map +1 -0
- package/dist/{adapter-http-express-B39rPhqH.mjs → adapter-http-express-78KD77cI.mjs} +11 -11
- package/dist/adapter-http-express-78KD77cI.mjs.map +1 -0
- package/dist/{adapter-http-fastify-BwXO6rqE.mjs → adapter-http-fastify-Dk7aT_xw.mjs} +14 -13
- package/dist/adapter-http-fastify-Dk7aT_xw.mjs.map +1 -0
- package/dist/base-document-models-CNHrVpOU.mjs +1861 -0
- package/dist/base-document-models-CNHrVpOU.mjs.map +1 -0
- package/dist/create-schema-ClPWjRPY.d.mts +161 -0
- package/dist/create-schema-ClPWjRPY.d.mts.map +1 -0
- package/dist/error-info-Cr6oQACe.mjs +601 -0
- package/dist/error-info-Cr6oQACe.mjs.map +1 -0
- package/dist/index.d.mts +3234 -979
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +7300 -2723
- package/dist/index.mjs.map +1 -1
- package/dist/package-subgraph-check-DdZLhOHW.mjs +138 -0
- package/dist/package-subgraph-check-DdZLhOHW.mjs.map +1 -0
- package/dist/pglite-like-CKQEL_Q0.d.mts +27 -0
- package/dist/pglite-like-CKQEL_Q0.d.mts.map +1 -0
- package/dist/pglite-node-CcX2YT-l.mjs +744 -0
- package/dist/pglite-node-CcX2YT-l.mjs.map +1 -0
- package/dist/rolldown-runtime-8H4AJuhK.mjs +16 -0
- package/dist/run-node-handler-CQjyjOuN.mjs +52 -0
- package/dist/run-node-handler-CQjyjOuN.mjs.map +1 -0
- package/dist/src/graphql/subgraph-types.d.mts +43 -0
- package/dist/src/graphql/subgraph-types.d.mts.map +1 -0
- package/dist/src/graphql/subgraph-types.mjs +14 -0
- package/dist/src/graphql/subgraph-types.mjs.map +1 -0
- package/dist/src/packages/https-hooks.d.mts +4 -4
- package/dist/src/packages/https-hooks.d.mts.map +1 -1
- package/dist/src/packages/https-hooks.mjs +2 -2
- package/dist/src/packages/https-hooks.mjs.map +1 -1
- package/dist/src/packages/vite-loader.d.mts +30 -9
- package/dist/src/packages/vite-loader.d.mts.map +1 -1
- package/dist/src/packages/vite-loader.mjs +198 -85
- package/dist/src/packages/vite-loader.mjs.map +1 -1
- package/dist/src/pglite/pglite-node.d.mts +434 -0
- package/dist/src/pglite/pglite-node.d.mts.map +1 -0
- package/dist/src/pglite/pglite-node.mjs +5 -0
- package/dist/src/pglite/worker/entry.d.mts +2 -0
- package/dist/src/pglite/worker/entry.mjs +298 -0
- package/dist/src/pglite/worker/entry.mjs.map +1 -0
- package/dist/subgraph-extraction-DioqM_Dc.mjs +1879 -0
- package/dist/subgraph-extraction-DioqM_Dc.mjs.map +1 -0
- package/dist/subgraph-schema-owner-BEjuk2Xv.mjs +10 -0
- package/dist/subgraph-schema-owner-BEjuk2Xv.mjs.map +1 -0
- package/dist/types-PXB1ctpi.d.mts +99 -0
- package/dist/types-PXB1ctpi.d.mts.map +1 -0
- package/package.json +39 -26
- package/dist/adapter-gateway-apollo-CxJNBVyD.mjs.map +0 -1
- package/dist/adapter-gateway-apollo-DowrX6E_.mjs +0 -4
- package/dist/adapter-gateway-mercurius-CZVy88Za.mjs.map +0 -1
- package/dist/adapter-gateway-stitching-CaZjvRzx.mjs +0 -316
- package/dist/adapter-gateway-stitching-CaZjvRzx.mjs.map +0 -1
- package/dist/adapter-http-express-B39rPhqH.mjs.map +0 -1
- package/dist/adapter-http-fastify-BwXO6rqE.mjs.map +0 -1
- package/dist/path-normalize-BOQwY9wR.mjs +0 -23
- package/dist/path-normalize-BOQwY9wR.mjs.map +0 -1
- package/dist/types-DcYyNcHJ.d.mts +0 -48
- package/dist/types-DcYyNcHJ.d.mts.map +0 -1
- package/dist/utils-XWVecaNn.mjs +0 -653
- package/dist/utils-XWVecaNn.mjs.map +0 -1
- package/dist/websocket-DncAB9XK.mjs +0 -18
- package/dist/websocket-DncAB9XK.mjs.map +0 -1
|
@@ -0,0 +1,744 @@
|
|
|
1
|
+
|
|
2
|
+
!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]="8c5d8636-4e82-5d46-982c-c40ed34f74ce")}catch(e){}}();
|
|
3
|
+
import { o as syncDirectory, s as syncTree, t as fromPGliteErrorInfo } from "./error-info-Cr6oQACe.mjs";
|
|
4
|
+
import { createRequire } from "node:module";
|
|
5
|
+
import { childLogger } from "document-model";
|
|
6
|
+
import { registerTelemetryWorker } from "@powerhousedao/reactor";
|
|
7
|
+
import { AsyncLocalStorage } from "node:async_hooks";
|
|
8
|
+
import path from "node:path";
|
|
9
|
+
import { existsSync, promises } from "node:fs";
|
|
10
|
+
import { PGlite } from "@electric-sql/pglite";
|
|
11
|
+
import { NodeFS } from "@electric-sql/pglite/nodefs";
|
|
12
|
+
import v8 from "node:v8";
|
|
13
|
+
import { Worker } from "node:worker_threads";
|
|
14
|
+
//#region src/pglite/snapshot-reader.ts
|
|
15
|
+
const SNAPSHOT_FILE_NAME = "snapshot.bin";
|
|
16
|
+
const MAGIC = new Uint8Array([
|
|
17
|
+
80,
|
|
18
|
+
71,
|
|
19
|
+
76,
|
|
20
|
+
65
|
|
21
|
+
]);
|
|
22
|
+
const FORMAT_VERSION = 1;
|
|
23
|
+
const HEADER_SIZE = 12;
|
|
24
|
+
const ENTRY_PREFIX_SIZE = 9;
|
|
25
|
+
const SKIPPED_ENTRIES = /* @__PURE__ */ new Set(["postmaster.pid"]);
|
|
26
|
+
const DEFAULT_IO_CHUNK_SIZE = 67108864;
|
|
27
|
+
/** Unpacks a snapshot into the existing `outDir`. */
|
|
28
|
+
async function extractSnapshot(snapshotPath, outDir, options = {}) {
|
|
29
|
+
const fh = await promises.open(snapshotPath, "r");
|
|
30
|
+
try {
|
|
31
|
+
const { size } = await fh.stat();
|
|
32
|
+
return await extractFromHandle(fh, size, outDir, options);
|
|
33
|
+
} finally {
|
|
34
|
+
await fh.close();
|
|
35
|
+
}
|
|
36
|
+
}
|
|
37
|
+
async function extractFromHandle(fh, fileSize, outDir, options) {
|
|
38
|
+
const root = path.resolve(outDir);
|
|
39
|
+
const reader = new ChunkedReader(fh, Math.min(options.chunkSize ?? DEFAULT_IO_CHUNK_SIZE, Math.max(1, fileSize)));
|
|
40
|
+
const header = await reader.take(HEADER_SIZE);
|
|
41
|
+
for (let i = 0; i < MAGIC.length; i++) if (header[i] !== MAGIC[i]) throw new Error("snapshot.bin: invalid snapshot magic");
|
|
42
|
+
const version = header.readUInt32LE(4);
|
|
43
|
+
if (version !== FORMAT_VERSION) throw new Error(`snapshot.bin: unsupported snapshot version ${version}`);
|
|
44
|
+
const count = header.readUInt32LE(8);
|
|
45
|
+
const decoder = new TextDecoder();
|
|
46
|
+
let pgVersionText;
|
|
47
|
+
let pgControl;
|
|
48
|
+
let written = 0;
|
|
49
|
+
for (let i = 0; i < count; i++) {
|
|
50
|
+
const prefix = await reader.take(ENTRY_PREFIX_SIZE);
|
|
51
|
+
const type = prefix.readUInt8(0);
|
|
52
|
+
const mode = prefix.readUInt32LE(1) & 4095;
|
|
53
|
+
const pathLen = prefix.readUInt32LE(5);
|
|
54
|
+
const relPath = decoder.decode(await reader.take(pathLen));
|
|
55
|
+
const dataLen = (await reader.take(4)).readUInt32LE(0);
|
|
56
|
+
const data = await reader.take(dataLen);
|
|
57
|
+
const full = resolveInside(root, relPath);
|
|
58
|
+
if (SKIPPED_ENTRIES.has(relPath)) continue;
|
|
59
|
+
if (type === 0) {
|
|
60
|
+
await promises.mkdir(full, { recursive: true });
|
|
61
|
+
await promises.chmod(full, dirMode(mode));
|
|
62
|
+
} else if (type === 1) {
|
|
63
|
+
await promises.mkdir(path.dirname(full), { recursive: true });
|
|
64
|
+
await promises.writeFile(full, data);
|
|
65
|
+
await promises.chmod(full, mode);
|
|
66
|
+
if (relPath === "PG_VERSION") pgVersionText = data.toString("utf8");
|
|
67
|
+
if (relPath === "global/pg_control") pgControl = data;
|
|
68
|
+
} else throw new Error(`snapshot.bin: unknown entry type ${type}`);
|
|
69
|
+
written++;
|
|
70
|
+
}
|
|
71
|
+
if (pgVersionText === void 0) throw new Error("snapshot.bin: no PG_VERSION entry");
|
|
72
|
+
const pgVersionMajor = Number.parseInt(pgVersionText.trim(), 10);
|
|
73
|
+
if (!Number.isInteger(pgVersionMajor) || pgVersionMajor <= 0) throw new Error(`snapshot.bin: unreadable PG_VERSION ${JSON.stringify(pgVersionText)}`);
|
|
74
|
+
if (options.sync ?? true) syncTree(root, options.hostFs);
|
|
75
|
+
return {
|
|
76
|
+
pgVersionMajor,
|
|
77
|
+
pgControl,
|
|
78
|
+
entries: written,
|
|
79
|
+
bytes: fileSize
|
|
80
|
+
};
|
|
81
|
+
}
|
|
82
|
+
function resolveInside(root, relPath) {
|
|
83
|
+
const full = path.resolve(root, relPath);
|
|
84
|
+
if (full !== root && !full.startsWith(root + path.sep)) throw new Error(`snapshot.bin: entry escapes the data dir: ${relPath}`);
|
|
85
|
+
return full;
|
|
86
|
+
}
|
|
87
|
+
/** NTFS has no execute bit; a Windows snapshot can carry untraversable dirs. */
|
|
88
|
+
function dirMode(mode) {
|
|
89
|
+
return mode & 4095 | 73;
|
|
90
|
+
}
|
|
91
|
+
var ChunkedReader = class {
|
|
92
|
+
fh;
|
|
93
|
+
buf;
|
|
94
|
+
start = 0;
|
|
95
|
+
end = 0;
|
|
96
|
+
position = 0;
|
|
97
|
+
constructor(fh, chunkSize) {
|
|
98
|
+
this.fh = fh;
|
|
99
|
+
this.buf = Buffer.allocUnsafe(Math.max(1, chunkSize));
|
|
100
|
+
}
|
|
101
|
+
async take(n) {
|
|
102
|
+
const out = Buffer.allocUnsafe(n);
|
|
103
|
+
let filled = 0;
|
|
104
|
+
while (filled < n) {
|
|
105
|
+
if (this.start === this.end) {
|
|
106
|
+
if (n - filled >= this.buf.byteLength) {
|
|
107
|
+
filled += await this.readInto(out, filled, n - filled);
|
|
108
|
+
continue;
|
|
109
|
+
}
|
|
110
|
+
this.start = 0;
|
|
111
|
+
this.end = await this.readInto(this.buf, 0, this.buf.byteLength);
|
|
112
|
+
}
|
|
113
|
+
const k = Math.min(this.end - this.start, n - filled);
|
|
114
|
+
this.buf.copy(out, filled, this.start, this.start + k);
|
|
115
|
+
this.start += k;
|
|
116
|
+
filled += k;
|
|
117
|
+
}
|
|
118
|
+
return out;
|
|
119
|
+
}
|
|
120
|
+
async readInto(target, offset, length) {
|
|
121
|
+
const { bytesRead } = await this.fh.read(target, offset, Math.min(length, this.buf.byteLength), this.position);
|
|
122
|
+
if (bytesRead <= 0) throw new Error("snapshot.bin: truncated snapshot");
|
|
123
|
+
this.position += bytesRead;
|
|
124
|
+
return bytesRead;
|
|
125
|
+
}
|
|
126
|
+
};
|
|
127
|
+
//#endregion
|
|
128
|
+
//#region src/pglite/convert-snapshot-dir.ts
|
|
129
|
+
const RM_OPTIONS = {
|
|
130
|
+
recursive: true,
|
|
131
|
+
force: true,
|
|
132
|
+
maxRetries: 5,
|
|
133
|
+
retryDelay: 100
|
|
134
|
+
};
|
|
135
|
+
function siblingsOf(dir) {
|
|
136
|
+
const resolved = path.resolve(dir);
|
|
137
|
+
return {
|
|
138
|
+
dir: resolved,
|
|
139
|
+
converting: `${resolved}.converting`,
|
|
140
|
+
old: `${resolved}.old`,
|
|
141
|
+
snapshot: path.join(resolved, SNAPSHOT_FILE_NAME)
|
|
142
|
+
};
|
|
143
|
+
}
|
|
144
|
+
/** Settles the debris of an interrupted conversion; runs before it at boot. */
|
|
145
|
+
async function recoverConversion(dir, deps) {
|
|
146
|
+
const s = siblingsOf(dir);
|
|
147
|
+
const [dirExists, convertingExists, oldExists] = await Promise.all([
|
|
148
|
+
exists(s.dir),
|
|
149
|
+
exists(s.converting),
|
|
150
|
+
exists(s.old)
|
|
151
|
+
]);
|
|
152
|
+
if (!dirExists) {
|
|
153
|
+
if (convertingExists) {
|
|
154
|
+
await promises.rename(s.converting, s.dir);
|
|
155
|
+
if (oldExists) await promises.rm(s.old, RM_OPTIONS);
|
|
156
|
+
deps.logger.warn(`PGlite conversion of ${s.dir} was interrupted after the swap started; completed it`);
|
|
157
|
+
return;
|
|
158
|
+
}
|
|
159
|
+
if (oldExists) throw new Error(`PGlite data dir ${s.dir} is missing but ${s.old} exists; refusing to initialize beside it. Inspect and rename or remove ${s.old}.`);
|
|
160
|
+
return;
|
|
161
|
+
}
|
|
162
|
+
if (await exists(s.snapshot)) {
|
|
163
|
+
if (convertingExists) await promises.rm(s.converting, RM_OPTIONS);
|
|
164
|
+
if (oldExists) await promises.rm(s.old, RM_OPTIONS);
|
|
165
|
+
return;
|
|
166
|
+
}
|
|
167
|
+
if (oldExists) await promises.rm(s.old, RM_OPTIONS);
|
|
168
|
+
if (convertingExists) {
|
|
169
|
+
deps.logger.warn(`Removing stray ${s.converting}; ${s.dir} holds no snapshot and is authoritative`);
|
|
170
|
+
await promises.rm(s.converting, RM_OPTIONS);
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
/** Extracts into `.converting`, verifies by opening it, swaps through `.old`. */
|
|
174
|
+
async function convertSnapshotDir(dir, deps) {
|
|
175
|
+
const s = siblingsOf(dir);
|
|
176
|
+
if (!await exists(s.snapshot)) return "none";
|
|
177
|
+
const startedAt = performance.now();
|
|
178
|
+
await promises.rm(s.converting, RM_OPTIONS);
|
|
179
|
+
await promises.mkdir(s.converting, { mode: 448 });
|
|
180
|
+
let snapshotBytes;
|
|
181
|
+
let entries;
|
|
182
|
+
try {
|
|
183
|
+
({bytes: snapshotBytes, entries} = await extractAndVerify(s, deps));
|
|
184
|
+
} catch (err) {
|
|
185
|
+
await promises.rm(s.converting, RM_OPTIONS);
|
|
186
|
+
throw err;
|
|
187
|
+
}
|
|
188
|
+
const parent = path.dirname(s.dir);
|
|
189
|
+
await promises.rename(s.dir, s.old);
|
|
190
|
+
syncDirectory(parent, deps.hostFs);
|
|
191
|
+
await deps.afterStep?.("renameOld");
|
|
192
|
+
await promises.rename(s.converting, s.dir);
|
|
193
|
+
syncDirectory(parent, deps.hostFs);
|
|
194
|
+
await deps.afterStep?.("renameNew");
|
|
195
|
+
try {
|
|
196
|
+
await promises.rm(s.old, RM_OPTIONS);
|
|
197
|
+
} catch (err) {
|
|
198
|
+
deps.logger.warn(`Could not remove ${s.old} after conversion; it is removed at the next boot: ${String(err)}`);
|
|
199
|
+
}
|
|
200
|
+
await deps.afterStep?.("removeOld");
|
|
201
|
+
const convertedBytes = await treeBytes(s.dir);
|
|
202
|
+
const durationMs = Math.round(performance.now() - startedAt);
|
|
203
|
+
deps.logger.info(`Converted PGlite snapshot at ${s.dir}: snapshot ${snapshotBytes} bytes -> ${convertedBytes} bytes on disk, ${entries} entries, ${durationMs} ms`);
|
|
204
|
+
return "converted";
|
|
205
|
+
}
|
|
206
|
+
async function extractAndVerify(s, deps) {
|
|
207
|
+
const extracted = await extractSnapshot(s.snapshot, s.converting, { sync: false });
|
|
208
|
+
await deps.afterStep?.("extract");
|
|
209
|
+
if (!extracted.pgControl) throw new Error(`${s.snapshot} has no global/pg_control entry`);
|
|
210
|
+
const expectedIdentifier = extracted.pgControl.readBigUInt64LE(0).toString();
|
|
211
|
+
const handle = await deps.openForVerify(extracted.pgVersionMajor, s.converting);
|
|
212
|
+
try {
|
|
213
|
+
await verifyOpenStore(handle, expectedIdentifier);
|
|
214
|
+
} finally {
|
|
215
|
+
await handle.close();
|
|
216
|
+
}
|
|
217
|
+
await promises.rm(path.join(s.converting, "postmaster.pid"), { force: true });
|
|
218
|
+
if (await exists(path.join(s.converting, "snapshot.bin"))) throw new Error(`Extracted PGlite data dir ${s.converting} contains ${SNAPSHOT_FILE_NAME}`);
|
|
219
|
+
syncTree(s.converting, deps.hostFs);
|
|
220
|
+
await deps.afterStep?.("verify");
|
|
221
|
+
return {
|
|
222
|
+
bytes: extracted.bytes,
|
|
223
|
+
entries: extracted.entries
|
|
224
|
+
};
|
|
225
|
+
}
|
|
226
|
+
async function verifyOpenStore(handle, expectedIdentifier) {
|
|
227
|
+
const actual = (await handle.query("SELECT system_identifier::text AS system_identifier FROM pg_control_system()")).rows[0]?.system_identifier;
|
|
228
|
+
if (actual !== expectedIdentifier) throw new Error(`PGlite system identifier mismatch after extraction: pg_control says ${expectedIdentifier}, server says ${String(actual)}`);
|
|
229
|
+
const tables = await handle.query("SELECT format('%I.%I', schemaname, tablename) AS qualified FROM pg_tables WHERE schemaname NOT IN ('pg_catalog', 'information_schema') ORDER BY 1");
|
|
230
|
+
for (const { qualified } of tables.rows) await handle.query(`SELECT count(*) FROM ${qualified}`);
|
|
231
|
+
}
|
|
232
|
+
async function exists(p) {
|
|
233
|
+
try {
|
|
234
|
+
await promises.lstat(p);
|
|
235
|
+
return true;
|
|
236
|
+
} catch {
|
|
237
|
+
return false;
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
async function treeBytes(dir) {
|
|
241
|
+
let total = 0;
|
|
242
|
+
const entries = await promises.readdir(dir, { withFileTypes: true });
|
|
243
|
+
for (const entry of entries) {
|
|
244
|
+
const full = path.join(dir, entry.name);
|
|
245
|
+
if (entry.isDirectory()) total += await treeBytes(full);
|
|
246
|
+
else if (entry.isFile()) total += (await promises.stat(full)).size;
|
|
247
|
+
}
|
|
248
|
+
return total;
|
|
249
|
+
}
|
|
250
|
+
//#endregion
|
|
251
|
+
//#region src/pglite/preflight.ts
|
|
252
|
+
/** PG major of the pinned @electric-sql/pglite; it exports none, so the test checks initdb. */
|
|
253
|
+
const CURRENT_PGLITE_MAJOR = 17;
|
|
254
|
+
/** `openForVerify` over the loaded PGlite module only. */
|
|
255
|
+
async function openCurrentPgliteForVerify(major, dataDir) {
|
|
256
|
+
if (major !== 17) throw new Error(`PGlite snapshot at ${dataDir} is PG${major}; this process only opens PG17 data dirs`);
|
|
257
|
+
const pg = new PGlite({ fs: new NodeFS(dataDir) });
|
|
258
|
+
await pg.waitReady;
|
|
259
|
+
return pg;
|
|
260
|
+
}
|
|
261
|
+
/** Converts a snapshot store and clears the files a previous run leaves behind. */
|
|
262
|
+
async function preparePgliteDataDir(dir, deps) {
|
|
263
|
+
await recoverConversion(dir, deps);
|
|
264
|
+
await convertSnapshotDir(dir, deps);
|
|
265
|
+
await removeStalePgliteFiles(dir, deps.logger);
|
|
266
|
+
}
|
|
267
|
+
/** PGlite leaves `postmaster.pid` after every close and `pg_wal/xlogtemp.*` after some. */
|
|
268
|
+
async function removeStalePgliteFiles(dir, logger) {
|
|
269
|
+
const lockfile = path.join(dir, "postmaster.pid");
|
|
270
|
+
let hadLockfile = true;
|
|
271
|
+
try {
|
|
272
|
+
await promises.unlink(lockfile);
|
|
273
|
+
} catch {
|
|
274
|
+
hadLockfile = false;
|
|
275
|
+
}
|
|
276
|
+
if (hadLockfile) logger.debug(`Removed PGlite lockfile ${lockfile}`);
|
|
277
|
+
const walDir = path.join(dir, "pg_wal");
|
|
278
|
+
let names;
|
|
279
|
+
try {
|
|
280
|
+
names = await promises.readdir(walDir);
|
|
281
|
+
} catch {
|
|
282
|
+
return;
|
|
283
|
+
}
|
|
284
|
+
for (const name of names) {
|
|
285
|
+
if (!name.startsWith("xlogtemp.")) continue;
|
|
286
|
+
await promises.rm(path.join(walDir, name), { force: true });
|
|
287
|
+
logger.debug(`Removed PGlite temp WAL file ${path.join(walDir, name)}`);
|
|
288
|
+
}
|
|
289
|
+
}
|
|
290
|
+
//#endregion
|
|
291
|
+
//#region src/pglite/wasm-wrapper-tiering.ts
|
|
292
|
+
const WASM_WRAPPER_TIERING_FLAG = "--wasm-wrapper-tiering-budget=1000000000";
|
|
293
|
+
let applied = false;
|
|
294
|
+
/** Node 24 V8 double-frees tiered wasm wrappers as instances die (#66366). */
|
|
295
|
+
function disableWasmWrapperTiering() {
|
|
296
|
+
if (applied || process.versions.node.split(".")[0] !== "24") return false;
|
|
297
|
+
v8.setFlagsFromString(WASM_WRAPPER_TIERING_FLAG);
|
|
298
|
+
applied = true;
|
|
299
|
+
return true;
|
|
300
|
+
}
|
|
301
|
+
//#endregion
|
|
302
|
+
//#region src/pglite/worker/errors.ts
|
|
303
|
+
/** Base class for failures of the worker itself, as opposed to SQL errors. */
|
|
304
|
+
var PGliteWorkerError = class extends Error {
|
|
305
|
+
label;
|
|
306
|
+
constructor(label, message, options) {
|
|
307
|
+
super(message, options);
|
|
308
|
+
this.label = label;
|
|
309
|
+
this.name = "PGliteWorkerError";
|
|
310
|
+
}
|
|
311
|
+
};
|
|
312
|
+
/** The worker could not open its store; every call on the stand-in fails with this. */
|
|
313
|
+
var PGliteWorkerInitError = class extends PGliteWorkerError {
|
|
314
|
+
constructor(label, options) {
|
|
315
|
+
super(label, `PGlite worker for ${label} failed to open its store`, options);
|
|
316
|
+
this.name = "PGliteWorkerInitError";
|
|
317
|
+
}
|
|
318
|
+
};
|
|
319
|
+
/** The worker thread exited (crash, terminate, out of memory) before answering. */
|
|
320
|
+
var PGliteWorkerExitedError = class extends PGliteWorkerError {
|
|
321
|
+
exitCode;
|
|
322
|
+
constructor(label, exitCode, options) {
|
|
323
|
+
super(label, `PGlite worker for ${label} exited with code ${exitCode}`, options);
|
|
324
|
+
this.exitCode = exitCode;
|
|
325
|
+
this.name = "PGliteWorkerExitedError";
|
|
326
|
+
}
|
|
327
|
+
};
|
|
328
|
+
/** A call was made after `close()` started. */
|
|
329
|
+
var PGliteWorkerClosedError = class extends PGliteWorkerError {
|
|
330
|
+
constructor(label) {
|
|
331
|
+
super(label, `PGlite worker for ${label} is closed`);
|
|
332
|
+
this.name = "PGliteWorkerClosedError";
|
|
333
|
+
}
|
|
334
|
+
};
|
|
335
|
+
//#endregion
|
|
336
|
+
//#region src/pglite/worker/protocol.ts
|
|
337
|
+
const CURRENT_PGLITE_MODULE = {
|
|
338
|
+
pglite: "@electric-sql/pglite",
|
|
339
|
+
nodefs: "@electric-sql/pglite/nodefs"
|
|
340
|
+
};
|
|
341
|
+
//#endregion
|
|
342
|
+
//#region src/pglite/worker/threaded-pglite.ts
|
|
343
|
+
const DEFAULT_PGLITE_WORKER_MEMORY_MB = 1024;
|
|
344
|
+
const DEFAULT_PGLITE_WORKER_CLOSE_GRACE_MS = 6e4;
|
|
345
|
+
/** `PH_PGLITE_WORKER_MEMORY_MB`, else {@link DEFAULT_PGLITE_WORKER_MEMORY_MB}. */
|
|
346
|
+
function resolvePgliteWorkerMemoryMb(env) {
|
|
347
|
+
const raw = env.PH_PGLITE_WORKER_MEMORY_MB;
|
|
348
|
+
if (raw === void 0 || raw.trim() === "") return DEFAULT_PGLITE_WORKER_MEMORY_MB;
|
|
349
|
+
const parsed = Number(raw);
|
|
350
|
+
if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`PH_PGLITE_WORKER_MEMORY_MB must be a positive integer (got: ${raw})`);
|
|
351
|
+
return parsed;
|
|
352
|
+
}
|
|
353
|
+
/**
|
|
354
|
+
* Main-thread stand-in for a PGlite instance whose store lives in a worker
|
|
355
|
+
* thread. It has the surface knex-pglite, kysely-pglite-dialect and
|
|
356
|
+
* `HardenedPGliteDialect` use: `waitReady`, `query`, `exec`, a synchronous
|
|
357
|
+
* `isInTransaction()`, `closed` and `close()`.
|
|
358
|
+
*
|
|
359
|
+
* Construction is synchronous and starts the worker; calls made before the
|
|
360
|
+
* worker is ready are queued behind its open. The worker runs requests one at
|
|
361
|
+
* a time in arrival order, and every answer carries the transaction status.
|
|
362
|
+
* The instance is a plain extensible object, since knex stores its own
|
|
363
|
+
* bookkeeping on the connection.
|
|
364
|
+
*/
|
|
365
|
+
var ThreadedPGlite = class {
|
|
366
|
+
label;
|
|
367
|
+
/** Settles once the worker has opened the store; rejects with {@link PGliteWorkerInitError}. */
|
|
368
|
+
waitReady;
|
|
369
|
+
worker;
|
|
370
|
+
logger;
|
|
371
|
+
closeGraceMs;
|
|
372
|
+
pending = /* @__PURE__ */ new Map();
|
|
373
|
+
/** The reservation an `admit` run is executing under, carried through its async calls. */
|
|
374
|
+
admission = new AsyncLocalStorage();
|
|
375
|
+
abortListeners = /* @__PURE__ */ new Set();
|
|
376
|
+
exitListeners = /* @__PURE__ */ new Set();
|
|
377
|
+
nextId = 1;
|
|
378
|
+
phase = "starting";
|
|
379
|
+
inTransaction = false;
|
|
380
|
+
terminalError = null;
|
|
381
|
+
workerError = null;
|
|
382
|
+
abortReason = null;
|
|
383
|
+
closePromise = null;
|
|
384
|
+
forgetTelemetry;
|
|
385
|
+
constructor(options) {
|
|
386
|
+
this.label = options.store.label;
|
|
387
|
+
this.logger = options.logger ?? childLogger([
|
|
388
|
+
"reactor-api",
|
|
389
|
+
"pglite-worker",
|
|
390
|
+
this.label
|
|
391
|
+
]);
|
|
392
|
+
this.closeGraceMs = options.closeGraceMs ?? 6e4;
|
|
393
|
+
const memoryLimitMb = options.memoryLimitMb ?? resolvePgliteWorkerMemoryMb(process.env);
|
|
394
|
+
const workerScript = options.workerScript ?? pgliteWorkerEntryPath;
|
|
395
|
+
if (workerScript === null) throw new Error("No PGlite worker script is available: build @powerhousedao/reactor-api or pass workerScript");
|
|
396
|
+
disableWasmWrapperTiering();
|
|
397
|
+
this.worker = new Worker(workerScript, {
|
|
398
|
+
name: `pglite:${this.label}`,
|
|
399
|
+
resourceLimits: { maxOldGenerationSizeMb: memoryLimitMb }
|
|
400
|
+
});
|
|
401
|
+
this.worker.on("message", (msg) => this.handleMessage(msg));
|
|
402
|
+
this.worker.on("error", (err) => this.handleWorkerError(err));
|
|
403
|
+
this.worker.on("exit", (code) => this.handleExit(code));
|
|
404
|
+
this.forgetTelemetry = registerTelemetryWorker(`pglite:${this.label}`, () => this.memoryStats());
|
|
405
|
+
this.waitReady = this.request("init", (id) => ({
|
|
406
|
+
type: "init",
|
|
407
|
+
id,
|
|
408
|
+
store: options.store
|
|
409
|
+
})).then(() => {
|
|
410
|
+
if (this.phase === "starting") this.phase = "ready";
|
|
411
|
+
}, (error) => {
|
|
412
|
+
const initError = error instanceof PGliteWorkerInitError ? error : new PGliteWorkerInitError(this.label, { cause: error });
|
|
413
|
+
this.fail(initError);
|
|
414
|
+
throw initError;
|
|
415
|
+
});
|
|
416
|
+
this.waitReady.catch(() => void 0);
|
|
417
|
+
}
|
|
418
|
+
/** JS heap of the worker and the WASM linear memory, which only grows. */
|
|
419
|
+
async memoryStats() {
|
|
420
|
+
const [heap, wasm] = await Promise.all([this.worker.getHeapStatistics(), this.request("stats", (id) => ({
|
|
421
|
+
type: "stats",
|
|
422
|
+
id
|
|
423
|
+
}))]);
|
|
424
|
+
return {
|
|
425
|
+
heapUsed: heap.used_heap_size,
|
|
426
|
+
wasm
|
|
427
|
+
};
|
|
428
|
+
}
|
|
429
|
+
/** True once the store is open and until close starts. */
|
|
430
|
+
get ready() {
|
|
431
|
+
return this.phase === "ready";
|
|
432
|
+
}
|
|
433
|
+
/** True once close has started or the worker is gone. */
|
|
434
|
+
get closed() {
|
|
435
|
+
return this.phase === "closing" || this.phase === "closed";
|
|
436
|
+
}
|
|
437
|
+
/** The reason the worker reported for a wasm abort, or null. */
|
|
438
|
+
get aborted() {
|
|
439
|
+
return this.abortReason;
|
|
440
|
+
}
|
|
441
|
+
/** The limits the worker thread runs under (empty once it has exited). */
|
|
442
|
+
get resourceLimits() {
|
|
443
|
+
return this.worker.resourceLimits ?? {};
|
|
444
|
+
}
|
|
445
|
+
/** The worker's thread id, for diagnostics. */
|
|
446
|
+
get threadId() {
|
|
447
|
+
return this.worker.threadId;
|
|
448
|
+
}
|
|
449
|
+
async query(sql, params, options) {
|
|
450
|
+
const wireOptions = toWireOptions(options);
|
|
451
|
+
return toResults(await this.request("query", (id) => ({
|
|
452
|
+
type: "query",
|
|
453
|
+
id,
|
|
454
|
+
admission: this.currentAdmission(),
|
|
455
|
+
sql,
|
|
456
|
+
params: params ?? [],
|
|
457
|
+
options: wireOptions
|
|
458
|
+
})));
|
|
459
|
+
}
|
|
460
|
+
async exec(sql, options) {
|
|
461
|
+
const wireOptions = toWireOptions(options);
|
|
462
|
+
return (await this.request("exec", (id) => ({
|
|
463
|
+
type: "exec",
|
|
464
|
+
id,
|
|
465
|
+
admission: this.currentAdmission(),
|
|
466
|
+
sql,
|
|
467
|
+
options: wireOptions
|
|
468
|
+
}))).map((result) => toResults(result));
|
|
469
|
+
}
|
|
470
|
+
/**
|
|
471
|
+
* `HardenedPGliteDialect`'s admission hook: `run` starts only once the worker
|
|
472
|
+
* can run its statements at once, with nothing queued ahead and no
|
|
473
|
+
* maintenance pass in progress, so the dialect's statement deadline (which
|
|
474
|
+
* starts inside `run`) never counts time spent waiting behind other work.
|
|
475
|
+
* Statements `run` issues bypass the queue until it settles; everything
|
|
476
|
+
* else waits behind them.
|
|
477
|
+
*/
|
|
478
|
+
async admit(run) {
|
|
479
|
+
let reservation = 0;
|
|
480
|
+
await this.request("reserve", (id) => {
|
|
481
|
+
reservation = id;
|
|
482
|
+
return {
|
|
483
|
+
type: "reserve",
|
|
484
|
+
id
|
|
485
|
+
};
|
|
486
|
+
});
|
|
487
|
+
try {
|
|
488
|
+
return await this.admission.run(reservation, run);
|
|
489
|
+
} finally {
|
|
490
|
+
this.release(reservation);
|
|
491
|
+
}
|
|
492
|
+
}
|
|
493
|
+
/** Rewrites one table through the store's maintenance inside the worker. */
|
|
494
|
+
rewriteTable(request) {
|
|
495
|
+
return this.request("rewrite", (id) => ({
|
|
496
|
+
type: "rewrite-table",
|
|
497
|
+
id,
|
|
498
|
+
request
|
|
499
|
+
}));
|
|
500
|
+
}
|
|
501
|
+
/** The status after the most recently answered request, as PGlite reported it. */
|
|
502
|
+
isInTransaction() {
|
|
503
|
+
return this.inTransaction;
|
|
504
|
+
}
|
|
505
|
+
/** Closes PGlite inside the worker (its shutdown checkpoint), then terminates the thread. */
|
|
506
|
+
close() {
|
|
507
|
+
if (this.closePromise !== null) return this.closePromise;
|
|
508
|
+
if (this.phase === "closed") return Promise.resolve();
|
|
509
|
+
this.closePromise = this.closeWorker();
|
|
510
|
+
return this.closePromise;
|
|
511
|
+
}
|
|
512
|
+
/** Stops the thread at once, without PGlite's close; pending calls reject. */
|
|
513
|
+
async terminate() {
|
|
514
|
+
if (this.phase === "closed") return;
|
|
515
|
+
await this.worker.terminate();
|
|
516
|
+
}
|
|
517
|
+
onAbort(listener) {
|
|
518
|
+
this.abortListeners.add(listener);
|
|
519
|
+
return () => {
|
|
520
|
+
this.abortListeners.delete(listener);
|
|
521
|
+
};
|
|
522
|
+
}
|
|
523
|
+
onExit(listener) {
|
|
524
|
+
this.exitListeners.add(listener);
|
|
525
|
+
return () => {
|
|
526
|
+
this.exitListeners.delete(listener);
|
|
527
|
+
};
|
|
528
|
+
}
|
|
529
|
+
async closeWorker() {
|
|
530
|
+
if (this.terminalError !== null) {
|
|
531
|
+
this.phase = "closing";
|
|
532
|
+
await this.worker.terminate();
|
|
533
|
+
return;
|
|
534
|
+
}
|
|
535
|
+
const closing = this.request("close", (id) => ({
|
|
536
|
+
type: "close",
|
|
537
|
+
id
|
|
538
|
+
}));
|
|
539
|
+
this.phase = "closing";
|
|
540
|
+
let timer;
|
|
541
|
+
const grace = new Promise((resolve) => {
|
|
542
|
+
timer = setTimeout(() => resolve("timeout"), this.closeGraceMs);
|
|
543
|
+
});
|
|
544
|
+
let outcome = "closed";
|
|
545
|
+
let closeError = null;
|
|
546
|
+
try {
|
|
547
|
+
outcome = await Promise.race([closing.then(() => "closed"), grace]);
|
|
548
|
+
} catch (error) {
|
|
549
|
+
closeError = error instanceof Error ? error : new Error(String(error));
|
|
550
|
+
} finally {
|
|
551
|
+
clearTimeout(timer);
|
|
552
|
+
}
|
|
553
|
+
if (outcome === "timeout") this.logger.warn(`PGlite worker for ${this.label} did not close within ${this.closeGraceMs}ms; terminating`);
|
|
554
|
+
await this.worker.terminate();
|
|
555
|
+
if (closeError !== null) throw closeError;
|
|
556
|
+
}
|
|
557
|
+
currentAdmission() {
|
|
558
|
+
return this.admission.getStore() ?? null;
|
|
559
|
+
}
|
|
560
|
+
release(reservation) {
|
|
561
|
+
if (this.phase === "closed") return;
|
|
562
|
+
const message = {
|
|
563
|
+
type: "release",
|
|
564
|
+
id: reservation
|
|
565
|
+
};
|
|
566
|
+
this.worker.postMessage(message);
|
|
567
|
+
}
|
|
568
|
+
request(kind, build) {
|
|
569
|
+
if (this.terminalError !== null) return Promise.reject(this.terminalError);
|
|
570
|
+
if (kind !== "init" && this.closed) return Promise.reject(new PGliteWorkerClosedError(this.label));
|
|
571
|
+
const id = this.nextId++;
|
|
572
|
+
const promise = new Promise((resolve, reject) => {
|
|
573
|
+
this.pending.set(id, {
|
|
574
|
+
kind,
|
|
575
|
+
resolve,
|
|
576
|
+
reject
|
|
577
|
+
});
|
|
578
|
+
});
|
|
579
|
+
this.worker.postMessage(build(id));
|
|
580
|
+
return promise;
|
|
581
|
+
}
|
|
582
|
+
handleMessage(msg) {
|
|
583
|
+
switch (msg.type) {
|
|
584
|
+
case "admitted":
|
|
585
|
+
this.settle(msg.id, msg.inTransaction, void 0);
|
|
586
|
+
return;
|
|
587
|
+
case "ready":
|
|
588
|
+
this.settle(msg.id, msg.inTransaction, void 0);
|
|
589
|
+
return;
|
|
590
|
+
case "query-result":
|
|
591
|
+
this.settle(msg.id, msg.inTransaction, msg.result);
|
|
592
|
+
return;
|
|
593
|
+
case "exec-result":
|
|
594
|
+
this.settle(msg.id, msg.inTransaction, msg.results);
|
|
595
|
+
return;
|
|
596
|
+
case "stats-result":
|
|
597
|
+
this.settle(msg.id, this.inTransaction, msg.wasmBytes);
|
|
598
|
+
return;
|
|
599
|
+
case "rewrite-table-result":
|
|
600
|
+
this.settle(msg.id, msg.inTransaction, msg.result);
|
|
601
|
+
return;
|
|
602
|
+
case "closed":
|
|
603
|
+
this.settle(msg.id, false, void 0);
|
|
604
|
+
return;
|
|
605
|
+
case "error":
|
|
606
|
+
this.settleError(msg.id, msg.inTransaction, fromPGliteErrorInfo(msg.error));
|
|
607
|
+
return;
|
|
608
|
+
case "abort":
|
|
609
|
+
this.handleAbort(msg.reason);
|
|
610
|
+
return;
|
|
611
|
+
case "log":
|
|
612
|
+
this.handleLog(msg);
|
|
613
|
+
return;
|
|
614
|
+
}
|
|
615
|
+
}
|
|
616
|
+
settle(id, inTransaction, value) {
|
|
617
|
+
this.inTransaction = inTransaction;
|
|
618
|
+
const entry = this.pending.get(id);
|
|
619
|
+
if (entry === void 0) return;
|
|
620
|
+
this.pending.delete(id);
|
|
621
|
+
entry.resolve(value);
|
|
622
|
+
}
|
|
623
|
+
settleError(id, inTransaction, error) {
|
|
624
|
+
this.inTransaction = inTransaction;
|
|
625
|
+
const entry = this.pending.get(id);
|
|
626
|
+
if (entry === void 0) return;
|
|
627
|
+
this.pending.delete(id);
|
|
628
|
+
entry.reject(error);
|
|
629
|
+
}
|
|
630
|
+
handleAbort(reason) {
|
|
631
|
+
if (this.abortReason !== null) return;
|
|
632
|
+
this.abortReason = reason;
|
|
633
|
+
this.logger.error(`PGlite worker for ${this.label} aborted: @reason`, reason);
|
|
634
|
+
for (const listener of [...this.abortListeners]) try {
|
|
635
|
+
listener(reason);
|
|
636
|
+
} catch (error) {
|
|
637
|
+
this.logger.error("PGlite abort listener threw: @error", error);
|
|
638
|
+
}
|
|
639
|
+
}
|
|
640
|
+
handleLog(msg) {
|
|
641
|
+
const message = `[${this.label}] ${msg.message}`;
|
|
642
|
+
const args = msg.error === void 0 ? [] : [fromPGliteErrorInfo(msg.error)];
|
|
643
|
+
const template = args.length > 0 ? `${message}: @error` : message;
|
|
644
|
+
switch (msg.level) {
|
|
645
|
+
case "debug":
|
|
646
|
+
this.logger.debug(template, ...args);
|
|
647
|
+
return;
|
|
648
|
+
case "info":
|
|
649
|
+
this.logger.info(template, ...args);
|
|
650
|
+
return;
|
|
651
|
+
case "warn":
|
|
652
|
+
this.logger.warn(template, ...args);
|
|
653
|
+
return;
|
|
654
|
+
case "error":
|
|
655
|
+
this.logger.error(template, ...args);
|
|
656
|
+
return;
|
|
657
|
+
default: msg.level;
|
|
658
|
+
}
|
|
659
|
+
}
|
|
660
|
+
handleWorkerError(err) {
|
|
661
|
+
this.workerError = err;
|
|
662
|
+
this.logger.error(`PGlite worker for ${this.label} failed: @error`, err);
|
|
663
|
+
}
|
|
664
|
+
handleExit(code) {
|
|
665
|
+
this.forgetTelemetry();
|
|
666
|
+
const graceful = this.phase === "closing" && this.terminalError === null;
|
|
667
|
+
this.phase = "closed";
|
|
668
|
+
this.inTransaction = false;
|
|
669
|
+
const error = graceful ? null : this.terminalError ?? new PGliteWorkerExitedError(this.label, code, { cause: this.workerError ?? void 0 });
|
|
670
|
+
if (error !== null && this.terminalError === null) this.terminalError = error;
|
|
671
|
+
this.rejectPending(error ?? new PGliteWorkerClosedError(this.label));
|
|
672
|
+
for (const listener of [...this.exitListeners]) try {
|
|
673
|
+
listener(error);
|
|
674
|
+
} catch (listenerError) {
|
|
675
|
+
this.logger.error("PGlite exit listener threw: @error", listenerError);
|
|
676
|
+
}
|
|
677
|
+
this.exitListeners.clear();
|
|
678
|
+
this.abortListeners.clear();
|
|
679
|
+
}
|
|
680
|
+
/** Records a fatal error and stops the thread; the exit rejects what is pending. */
|
|
681
|
+
fail(error) {
|
|
682
|
+
if (this.terminalError === null) this.terminalError = error;
|
|
683
|
+
this.rejectPending(error);
|
|
684
|
+
this.worker.terminate();
|
|
685
|
+
}
|
|
686
|
+
rejectPending(error) {
|
|
687
|
+
const entries = [...this.pending.values()];
|
|
688
|
+
this.pending.clear();
|
|
689
|
+
for (const entry of entries) entry.reject(error);
|
|
690
|
+
}
|
|
691
|
+
};
|
|
692
|
+
function toWireOptions(options) {
|
|
693
|
+
if (options === void 0) return {};
|
|
694
|
+
if (options.parsers !== void 0 || options.serializers !== void 0 || options.blob !== void 0 || options.onNotice !== void 0) throw new Error("ThreadedPGlite does not support parsers, serializers, blob or onNotice per query; configure parsers on the worker");
|
|
695
|
+
const wire = {};
|
|
696
|
+
if (options.rowMode !== void 0) wire.rowMode = options.rowMode;
|
|
697
|
+
if (options.paramTypes !== void 0) wire.paramTypes = options.paramTypes;
|
|
698
|
+
return wire;
|
|
699
|
+
}
|
|
700
|
+
function toResults(result) {
|
|
701
|
+
const out = {
|
|
702
|
+
rows: result.rows,
|
|
703
|
+
fields: result.fields
|
|
704
|
+
};
|
|
705
|
+
if (result.affectedRows !== void 0) out.affectedRows = result.affectedRows;
|
|
706
|
+
return out;
|
|
707
|
+
}
|
|
708
|
+
/**
|
|
709
|
+
* The worker script: the built entry (chunking may place this module in
|
|
710
|
+
* `dist/` or `dist/src/pglite/`), or, when this module runs from its
|
|
711
|
+
* TypeScript source, a bootstrap that loads the entry through tsx. Null when
|
|
712
|
+
* neither is available.
|
|
713
|
+
*/
|
|
714
|
+
function resolvePgliteWorkerEntryPath() {
|
|
715
|
+
if (/\.m?ts$/.test(new URL(import.meta.url).pathname)) return resolveSourceBootstrap();
|
|
716
|
+
return [
|
|
717
|
+
"./src/pglite/worker/entry.mjs",
|
|
718
|
+
"./worker/entry.mjs",
|
|
719
|
+
"./entry.mjs"
|
|
720
|
+
].map((relative) => fileUrlToPath(new URL(relative, import.meta.url))).find((candidate) => existsSync(candidate)) ?? null;
|
|
721
|
+
}
|
|
722
|
+
function resolveSourceBootstrap() {
|
|
723
|
+
const bootstrap = fileUrlToPath(new URL("./source-bootstrap.mjs", import.meta.url));
|
|
724
|
+
if (!existsSync(bootstrap)) return null;
|
|
725
|
+
try {
|
|
726
|
+
createRequire(import.meta.url).resolve("tsx/esm/api");
|
|
727
|
+
} catch {
|
|
728
|
+
return null;
|
|
729
|
+
}
|
|
730
|
+
return bootstrap;
|
|
731
|
+
}
|
|
732
|
+
function fileUrlToPath(url) {
|
|
733
|
+
if (url.protocol !== "file:") return url.href;
|
|
734
|
+
let pathname = decodeURIComponent(url.pathname);
|
|
735
|
+
if (/^\/[A-Za-z]:[/\\]/.test(pathname)) pathname = pathname.slice(1);
|
|
736
|
+
return pathname;
|
|
737
|
+
}
|
|
738
|
+
/** Absolute path of the worker script for `new Worker(...)`; null when none can run here. */
|
|
739
|
+
const pgliteWorkerEntryPath = resolvePgliteWorkerEntryPath();
|
|
740
|
+
//#endregion
|
|
741
|
+
export { convertSnapshotDir as _, resolvePgliteWorkerMemoryMb as a, extractSnapshot as b, PGliteWorkerError as c, WASM_WRAPPER_TIERING_FLAG as d, disableWasmWrapperTiering as f, removeStalePgliteFiles as g, preparePgliteDataDir as h, pgliteWorkerEntryPath as i, PGliteWorkerExitedError as l, openCurrentPgliteForVerify as m, DEFAULT_PGLITE_WORKER_MEMORY_MB as n, CURRENT_PGLITE_MODULE as o, CURRENT_PGLITE_MAJOR as p, ThreadedPGlite as r, PGliteWorkerClosedError as s, DEFAULT_PGLITE_WORKER_CLOSE_GRACE_MS as t, PGliteWorkerInitError as u, recoverConversion as v, SNAPSHOT_FILE_NAME as y };
|
|
742
|
+
|
|
743
|
+
//# sourceMappingURL=pglite-node-CcX2YT-l.mjs.map
|
|
744
|
+
//# debugId=8c5d8636-4e82-5d46-982c-c40ed34f74ce
|