@niscorp/moss 0.3.2 → 0.3.3

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.
Files changed (48) hide show
  1. package/CHANGELOG.md +102 -0
  2. package/DESIGN.md +84 -19
  3. package/DOCS.md +170 -35
  4. package/README.md +2 -2
  5. package/dist/{chunk-J72N3EMJ.js → chunk-4T6KAXBP.js} +45 -27
  6. package/dist/chunk-4T6KAXBP.js.map +1 -0
  7. package/dist/{chunk-ZP3C53AC.js → chunk-AUZMT3GL.js} +739 -654
  8. package/dist/chunk-AUZMT3GL.js.map +1 -0
  9. package/dist/{chunk-ZOEUEMDX.js → chunk-HOZID4EM.js} +131 -16
  10. package/dist/chunk-HOZID4EM.js.map +1 -0
  11. package/dist/chunk-NE2EXMTO.js +103 -0
  12. package/dist/chunk-NE2EXMTO.js.map +1 -0
  13. package/dist/client/node.cjs +1 -1
  14. package/dist/client/node.cjs.map +1 -1
  15. package/dist/client/node.js +1 -1
  16. package/dist/client/node.js.map +1 -1
  17. package/dist/client.cjs +60 -26
  18. package/dist/client.cjs.map +1 -1
  19. package/dist/client.d.cts +6 -1
  20. package/dist/client.d.ts +6 -1
  21. package/dist/client.js +2 -2
  22. package/dist/{document-D9khv9jI.d.cts → document-DhWxieUc.d.cts} +22 -3
  23. package/dist/{document-D9khv9jI.d.ts → document-DhWxieUc.d.ts} +22 -3
  24. package/dist/index.cjs +777 -572
  25. package/dist/index.cjs.map +1 -1
  26. package/dist/index.d.cts +19 -3
  27. package/dist/index.d.ts +19 -3
  28. package/dist/index.js +2 -2
  29. package/dist/node.cjs +370 -219
  30. package/dist/node.cjs.map +1 -1
  31. package/dist/node.d.cts +2 -1
  32. package/dist/node.d.ts +2 -1
  33. package/dist/node.js +3 -3
  34. package/dist/terminal/index.cjs +60 -26
  35. package/dist/terminal/index.cjs.map +1 -1
  36. package/dist/terminal/index.js +2 -2
  37. package/dist/vite.cjs +103 -28
  38. package/dist/vite.cjs.map +1 -1
  39. package/dist/vite.d.cts +1 -1
  40. package/dist/vite.d.ts +1 -1
  41. package/dist/vite.js +14 -9
  42. package/dist/vite.js.map +1 -1
  43. package/package.json +9 -9
  44. package/dist/chunk-J72N3EMJ.js.map +0 -1
  45. package/dist/chunk-SUVDISEG.js +0 -64
  46. package/dist/chunk-SUVDISEG.js.map +0 -1
  47. package/dist/chunk-ZOEUEMDX.js.map +0 -1
  48. package/dist/chunk-ZP3C53AC.js.map +0 -1
package/dist/index.cjs CHANGED
@@ -1,6 +1,6 @@
1
1
  'use strict';
2
2
 
3
- var crypto = require('crypto');
3
+ var crypto$1 = require('crypto');
4
4
  var postgres = require('@niscorp/strata/postgres');
5
5
  var async_hooks = require('async_hooks');
6
6
  var hono = require('hono');
@@ -11,10 +11,10 @@ var migrations$1 = require('@niscorp/nova/migrations');
11
11
  var migrations = require('@niscorp/prism/migrations');
12
12
  var charter = require('@niscorp/charter');
13
13
  var nova = require('@niscorp/nova');
14
- var tide = require('@niscorp/tide');
15
14
  var zod = require('zod');
16
15
  var reflect = require('@niscorp/nova/reflect');
17
16
  var i18n = require('@niscorp/nova/i18n');
17
+ var tide = require('@niscorp/tide');
18
18
  var prism = require('@niscorp/prism');
19
19
  var document = require('@niscorp/nova/document');
20
20
 
@@ -78,7 +78,7 @@ var wireFabric = (fabric, origin, apply) => {
78
78
  }
79
79
  };
80
80
  };
81
- var hashSessionToken = (token) => crypto.createHash("sha256").update(token).digest("hex");
81
+ var hashSessionToken = (token) => crypto$1.createHash("sha256").update(token).digest("hex");
82
82
  var SESSIONS_SEQUENCE = {
83
83
  id: "nisc.moss.sessions",
84
84
  migrations: [
@@ -104,7 +104,7 @@ var initSessions = async (pool) => {
104
104
  };
105
105
  var mintSession = async (pool, principal, ttlMs) => {
106
106
  await pool.query("DELETE FROM sessions WHERE expires_at < now()");
107
- const token = `st_${crypto.randomBytes(32).toString("base64url")}`;
107
+ const token = `st_${crypto$1.randomBytes(32).toString("base64url")}`;
108
108
  await pool.query("INSERT INTO sessions (token_hash, principal, expires_at) VALUES ($1, $2, $3)", [
109
109
  hashSessionToken(token),
110
110
  principal,
@@ -117,6 +117,11 @@ var sessionOf = async (pool, token) => {
117
117
  const principal = res.rows[0]?.principal;
118
118
  return typeof principal === "string" ? principal : null;
119
119
  };
120
+ var sessionRemainingMs = async (pool, token) => {
121
+ const res = await pool.query("SELECT extract(epoch from expires_at - now()) * 1000 AS remaining FROM sessions WHERE token_hash = $1 AND expires_at > now()", [hashSessionToken(token)]);
122
+ const remaining = Number(res.rows[0]?.["remaining"]);
123
+ return res.rows.length > 0 && Number.isFinite(remaining) ? remaining : null;
124
+ };
120
125
  var revokeSession = async (pool, token) => {
121
126
  await pool.query("DELETE FROM sessions WHERE token_hash = $1", [hashSessionToken(token)]);
122
127
  };
@@ -223,454 +228,95 @@ var createDataLayer = async (runtime, entries = []) => {
223
228
  const cache = runtime.cache ?? vex.createPostgresCache({ pool: runtime.pool });
224
229
  await cache.init?.();
225
230
  await vex.seedCache(cache, entries);
226
- const engine = vex.createQueryEngine({ adapter, cache });
231
+ const engine = vex.createQueryEngine({ adapter, cache, ...runtime.vexConfig !== void 0 ? { config: runtime.vexConfig } : {} });
227
232
  const schema = await engine.introspect();
228
233
  return { engine, schema, grants: vex.scopeGrants(schema.entities.map((e) => e.name)) };
229
234
  };
230
- var TIDE_TABLES = ["tide_fact", "tide_run", "tide_work", "tide_reflex_state"];
231
- var TIDE_DDL = `
232
- CREATE TABLE IF NOT EXISTS tide_fact (
233
- id text PRIMARY KEY,
234
- kind text NOT NULL CHECK (kind IN ('write','signal','manual','run')),
235
- entity text,
236
- op text CHECK (op IN ('insert','update','delete')),
237
- row jsonb,
238
- name text,
239
- payload jsonb,
240
- reflex text,
241
- run_id text,
242
- occurrence text,
243
- stats jsonb,
244
- target text,
245
- by text,
246
- at bigint NOT NULL,
247
- not_before bigint,
248
- dedupe_key text,
249
- cause text,
250
- depth integer NOT NULL DEFAULT 0,
251
- delivered_at bigint,
252
- parked text,
253
- released boolean,
254
- -- WHOSE FACT THIS IS. The identity of the reflex that minted it, absent on
255
- -- anything the host ingested. The matcher refuses to hand a fact minted
256
- -- under one identity to a reflex running under another, which is the only
257
- -- thing standing between a carried row and somebody else's effect \u2014 tide is
258
- -- the one place a row travels without being read, so no scope policy is
259
- -- consulted on the way.
260
- as_who text
261
- );
262
-
263
- -- A PARTIAL index, because a fact with no dedupeKey is not claiming to be
264
- -- unique: it is a distinct occurrence of something, not a repeat of it.
265
- -- entity is in the key: without it, two producers over different tables
266
- -- that agreed on a key value silently ate each other's rows.
267
- CREATE UNIQUE INDEX IF NOT EXISTS tide_fact_dedupe
268
- ON tide_fact (kind, coalesce(entity,''), coalesce(name,''), dedupe_key)
269
- WHERE dedupe_key IS NOT NULL;
270
-
271
- -- The matcher's query, every advance.
272
- CREATE INDEX IF NOT EXISTS tide_fact_due
273
- ON tide_fact (at) WHERE delivered_at IS NULL AND parked IS NULL;
274
- CREATE INDEX IF NOT EXISTS tide_fact_swept ON tide_fact (delivered_at);
275
-
276
- CREATE TABLE IF NOT EXISTS tide_run (
277
- id text PRIMARY KEY,
278
- reflex_id text NOT NULL,
279
- version text NOT NULL,
280
- as_who text,
281
- cause text NOT NULL,
282
- occurrence text,
283
- fact_ids jsonb,
284
- state text NOT NULL CHECK (state IN ('pending','fanned','settled','skipped')),
285
- depth integer NOT NULL DEFAULT 0,
286
- selected integer,
287
- total integer NOT NULL DEFAULT 0,
288
- done integer NOT NULL DEFAULT 0,
289
- failed integer NOT NULL DEFAULT 0,
290
- due_at bigint NOT NULL,
291
- created_at bigint NOT NULL,
292
- settled_at bigint,
293
- drained boolean,
294
- note text,
295
- -- THE IDEMPOTENCY. One constraint, every trigger kind: an occurrence
296
- -- cannot open twice, a replayed fact cannot open twice, and two instances
297
- -- ticking at the same moment contend instead of duplicating.
298
- UNIQUE (reflex_id, cause)
299
- );
300
-
301
- CREATE INDEX IF NOT EXISTS tide_run_pending ON tide_run (state, due_at);
302
- CREATE INDEX IF NOT EXISTS tide_run_ledger ON tide_run (reflex_id, created_at DESC);
303
- CREATE INDEX IF NOT EXISTS tide_run_swept ON tide_run (settled_at);
304
-
305
- CREATE TABLE IF NOT EXISTS tide_work (
306
- id text PRIMARY KEY,
307
- -- ON DELETE CASCADE, because a run and its work are one fact about the
308
- -- world. Sweeping runs and leaving work destroys the UNIQUE(run_id, unit)
309
- -- row that IS the "this unit already ran" record \u2014 and a restore then
310
- -- re-charges the invoice.
311
- run_id text NOT NULL REFERENCES tide_run(id) ON DELETE CASCADE,
312
- reflex_id text NOT NULL,
313
- unit text NOT NULL,
314
- cause text NOT NULL,
315
- env jsonb NOT NULL,
316
- depth integer NOT NULL DEFAULT 0,
317
- state text NOT NULL CHECK (state IN ('pending','claimed','retrying','done','failed')),
318
- attempt integer NOT NULL DEFAULT 0,
319
- token text,
320
- -- Zero, never null, when unclaimed: "never claimed or lapsed" is then one
321
- -- comparison rather than a disjunction.
322
- claimed_until bigint NOT NULL DEFAULT 0,
323
- not_before bigint NOT NULL,
324
- input jsonb,
325
- output jsonb,
326
- error text,
327
- created_at bigint NOT NULL,
328
- settled_at bigint,
329
- UNIQUE (run_id, unit)
330
- );
331
-
332
- CREATE INDEX IF NOT EXISTS tide_work_claimable ON tide_work (state, not_before, claimed_until);
333
- CREATE INDEX IF NOT EXISTS tide_work_run ON tide_work (run_id);
334
- CREATE INDEX IF NOT EXISTS tide_work_swept ON tide_work (settled_at);
335
-
336
- CREATE TABLE IF NOT EXISTS tide_reflex_state (
337
- reflex_id text PRIMARY KEY,
338
- armed_at bigint NOT NULL DEFAULT 0,
339
- materialized_through bigint
340
- );
341
235
 
342
- -- Polls are gone (the vex bridge pushes writes \u2014 a poll could only
343
- -- re-discover them late), and their cursor state goes with them. IF EXISTS,
344
- -- so a store created after the removal is not asked to drop what it never had.
345
- ALTER TABLE tide_reflex_state DROP COLUMN IF EXISTS poll_cursor;
346
- ALTER TABLE tide_reflex_state DROP COLUMN IF EXISTS poll_seen;
347
- ALTER TABLE tide_reflex_state DROP COLUMN IF EXISTS polled_at;
348
- `;
349
- var SQL_TABLE = {
350
- fact: "tide_fact",
351
- run: "tide_run",
352
- task: "tide_work",
353
- state: "tide_reflex_state"
354
- };
355
- var COLUMN_OVERRIDES = { as: "as_who" };
356
- var snake = (field) => COLUMN_OVERRIDES[field] ?? field.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
357
- var camel = (column) => {
358
- for (const [field, mapped] of Object.entries(COLUMN_OVERRIDES)) if (mapped === column) return field;
359
- return column.replace(/_([a-z])/g, (_all, c) => c.toUpperCase());
236
+ // src/generation.ts
237
+ var GENERATION_DDL = [
238
+ /* sql */
239
+ `CREATE TABLE IF NOT EXISTS moss_generation (id INT PRIMARY KEY, n BIGINT NOT NULL DEFAULT 0)`,
240
+ /* sql */
241
+ `INSERT INTO moss_generation (id, n) VALUES (1, 0) ON CONFLICT (id) DO NOTHING`
242
+ ];
243
+ var DEFAULT_GENERATION_POLL_MS = 60 * 1e3;
244
+ var createGeneration = (pool, ctx) => {
245
+ const everyMs = ctx.everyMs ?? DEFAULT_GENERATION_POLL_MS;
246
+ let seen = -1;
247
+ let checking = false;
248
+ const read = async () => {
249
+ if (checking) return;
250
+ checking = true;
251
+ try {
252
+ const result = await pool.query("SELECT n FROM moss_generation WHERE id = 1");
253
+ const n = Number(result.rows[0]?.n ?? 0);
254
+ if (!Number.isFinite(n)) return;
255
+ const first = seen === -1;
256
+ const moved = !first && n !== seen;
257
+ seen = n;
258
+ if (moved) await ctx.onMoved();
259
+ } catch (err) {
260
+ console.error("[moss:generation] could not read the generation pointer \u2014 this process may be serving stale resolutions", err);
261
+ } finally {
262
+ checking = false;
263
+ }
264
+ };
265
+ void read();
266
+ const timer = everyMs > 0 ? setInterval(() => void read(), everyMs) : void 0;
267
+ timer?.unref?.();
268
+ return {
269
+ bump: () => {
270
+ void pool.query("UPDATE moss_generation SET n = n + 1 WHERE id = 1").then(async () => {
271
+ const result = await pool.query("SELECT n FROM moss_generation WHERE id = 1");
272
+ seen = Number(result.rows[0]?.n ?? seen);
273
+ }).catch((err) => console.error("[moss:generation] could not move the pointer", err));
274
+ },
275
+ current: () => seen,
276
+ stop: () => {
277
+ if (timer !== void 0) clearInterval(timer);
278
+ }
279
+ };
360
280
  };
361
- var JSON_COLUMNS = /* @__PURE__ */ new Set(["row", "payload", "stats", "fact_ids", "env", "input", "output"]);
362
- var BIGINT_COLUMNS = /* @__PURE__ */ new Set([
363
- "at",
364
- "not_before",
365
- "delivered_at",
366
- "depth",
367
- "descendants",
368
- "due_at",
369
- "created_at",
370
- "settled_at",
371
- "claimed_until",
372
- "armed_at",
373
- "materialized_through",
374
- "attempt",
375
- "selected",
376
- "total",
377
- "done",
378
- "failed"
379
- ]);
380
- var toColumn = (column, value) => {
381
- if (value === void 0) return null;
382
- if (JSON_COLUMNS.has(column)) return JSON.stringify(value);
383
- return value;
281
+ var b64url = (buffer) => buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
282
+ var fromB64url = (text) => Buffer.from(text.replace(/-/g, "+").replace(/_/g, "/"), "base64");
283
+ var signerFromSeed = (seed) => {
284
+ const pkcs8 = Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), seed.subarray(0, 32)]);
285
+ const privateKey = crypto$1.createPrivateKey({ key: pkcs8, format: "der", type: "pkcs8" });
286
+ const asInput = privateKey;
287
+ return { privateKey, publicKey: crypto$1.createPublicKey(asInput) };
384
288
  };
385
- var fromColumn = (column, value) => {
386
- if (value === null) return void 0;
387
- if (JSON_COLUMNS.has(column)) return typeof value === "string" ? JSON.parse(value) : value;
388
- if (BIGINT_COLUMNS.has(column)) return Number(value);
389
- return value;
289
+ var createAssertionSigner = (seedB64) => {
290
+ const seed = seedB64 !== void 0 && seedB64 !== "" ? Buffer.from(seedB64, "base64") : void 0;
291
+ const { publicKey, privateKey } = seed !== void 0 && seed.length >= 32 ? signerFromSeed(seed) : crypto$1.generateKeyPairSync("ed25519");
292
+ const verifyKey = publicKey.export({ type: "spki", format: "der" }).toString("base64");
293
+ return {
294
+ verifyKey,
295
+ mint: (claims, ttlMs = 3e4) => {
296
+ const iat = Date.now();
297
+ const body = Buffer.from(JSON.stringify({ ...claims, iat, exp: iat + ttlMs }));
298
+ return `${b64url(body)}.${b64url(crypto$1.sign(null, body, privateKey))}`;
299
+ }
300
+ };
390
301
  };
391
- var rowToEntity = (table, row) => {
392
- const entity = {};
393
- for (const [column, value] of Object.entries(row)) {
394
- const mapped = fromColumn(column, value);
395
- if (mapped !== void 0) entity[camel(column)] = mapped;
302
+ var verifyAssertion = (token, verifyKey, now = Date.now()) => {
303
+ const dot = token.indexOf(".");
304
+ if (dot <= 0) return void 0;
305
+ try {
306
+ const body = fromB64url(token.slice(0, dot));
307
+ const signature = fromB64url(token.slice(dot + 1));
308
+ const key = crypto$1.createPublicKey({ key: fromB64url(verifyKey), format: "der", type: "spki" });
309
+ if (!crypto$1.verify(null, body, key, signature)) return void 0;
310
+ const parsed = JSON.parse(body.toString());
311
+ if (typeof parsed.integration !== "string" || typeof parsed.principal !== "string") return void 0;
312
+ if (typeof parsed.exp !== "number" || parsed.exp <= now) return void 0;
313
+ return parsed;
314
+ } catch {
315
+ return void 0;
396
316
  }
397
- return entity;
398
317
  };
399
- var COMPARATORS = { eq: "=", ne: "<>", lt: "<", lte: "<=", gt: ">", gte: ">=" };
400
- var compileWhere = (where, start, alias = "") => {
401
- const clauses = [];
402
- const params = [];
403
- const prefix = alias === "" ? "" : `${alias}.`;
404
- const slot = (value) => {
405
- params.push(value);
406
- return `$${start + params.length - 1}`;
407
- };
408
- for (const [field, test] of Object.entries(where ?? {})) {
409
- const column = `${prefix}${snake(field)}`;
410
- const bare = snake(field);
411
- if (test === null || typeof test !== "object" || Array.isArray(test)) {
412
- clauses.push(test === void 0 ? `${column} IS NULL` : `${column} = ${slot(toColumn(bare, test))}`);
413
- continue;
414
- }
415
- const comparison = test;
416
- for (const [op, symbol] of Object.entries(COMPARATORS)) {
417
- const operand = comparison[op];
418
- if (operand === void 0) continue;
419
- clauses.push(op === "ne" ? `(${column} IS NULL OR ${column} <> ${slot(toColumn(bare, operand))})` : `${column} ${symbol} ${slot(toColumn(bare, operand))}`);
420
- }
421
- if (comparison.in !== void 0) clauses.push(`${column} = ANY(${slot(comparison.in.map((value) => toColumn(bare, value)))})`);
422
- if (comparison.notIn !== void 0) clauses.push(`NOT (${column} = ANY(${slot(comparison.notIn.map((value) => toColumn(bare, value)))}))`);
423
- if (comparison.isNull !== void 0) clauses.push(comparison.isNull ? `${column} IS NULL` : `${column} IS NOT NULL`);
424
- }
425
- return { sql: clauses.length === 0 ? "TRUE" : clauses.join(" AND "), params };
426
- };
427
- var compileOrder = (order, alias = "") => {
428
- if (order === void 0 || order.length === 0) return "";
429
- const prefix = alias === "" ? "" : `${alias}.`;
430
- return ` ORDER BY ${order.map((key) => `${prefix}${snake(String(key.by))} ${key.dir === "desc" ? "DESC" : "ASC"}`).join(", ")}`;
431
- };
432
- var sortRows = (rows, order) => {
433
- if (order === void 0 || order.length === 0) return [...rows];
434
- return [...rows].sort((left, right) => {
435
- for (const key of order) {
436
- const a = left[String(key.by)];
437
- const b = right[String(key.by)];
438
- const compared = typeof a === "number" && typeof b === "number" ? a - b : String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
439
- if (compared !== 0) return compared * (key.dir === "desc" ? -1 : 1);
440
- }
441
- return 0;
442
- });
443
- };
444
- var compileSet = (set, start) => {
445
- const assignments = [];
446
- const params = [];
447
- for (const [field, value] of Object.entries(set)) {
448
- const column = snake(field);
449
- if (value !== null && typeof value === "object" && "inc" in value) {
450
- assignments.push(`${column} = coalesce(${column}, 0) + ${Number(value.inc)}`);
451
- continue;
452
- }
453
- params.push(toColumn(column, value));
454
- assignments.push(`${column} = $${start + params.length - 1}`);
455
- }
456
- return { sql: assignments.join(", "), params };
457
- };
458
- var mintId = /* @__PURE__ */ (() => {
459
- let sequence = 0;
460
- return (table) => {
461
- sequence += 1;
462
- return `${table}_${Date.now().toString(36)}_${sequence.toString(36)}`;
463
- };
464
- })();
465
- var statementsOf = (ddl) => ddl.split(";").map((chunk) => chunk.trim()).filter((chunk) => chunk.split("\n").some((line) => line.trim() !== "" && !line.trim().startsWith("--"))).map((sql) => ({ kind: "sql", sql }));
466
- var TIDE_SEQUENCE = {
467
- id: "nisc.moss.tide",
468
- migrations: [
469
- { description: "The tide store: facts, runs, work and reflex state, converged from any earlier shape", steps: statementsOf(TIDE_DDL) },
470
- {
471
- // A fact's chain: the root it belongs to, and — on a root — how many facts
472
- // the chain has minted beneath it. Nullable: every existing fact is a
473
- // root nothing has been counted against yet.
474
- description: "A fact carries its chain root, and a root counts what its chain minted (tide maxChainFacts)",
475
- steps: [
476
- { kind: "sql", sql: "ALTER TABLE tide_fact ADD COLUMN IF NOT EXISTS root text" },
477
- { kind: "sql", sql: "ALTER TABLE tide_fact ADD COLUMN IF NOT EXISTS descendants integer" }
478
- ]
479
- }
480
- ]
481
- };
482
- var createTideStore = (pool, options = {}) => {
483
- const ready = options.migrate === false ? Promise.resolve() : postgres.migrate(pool, [TIDE_SEQUENCE]).then(() => void 0);
484
- ready.catch(() => void 0);
485
- const build = (client) => {
486
- const store = {
487
- query: async (spec) => {
488
- await ready;
489
- const where = compileWhere(spec.where, 1);
490
- const limit = spec.limit === void 0 ? "" : ` LIMIT ${Math.max(0, Math.floor(spec.limit))}`;
491
- const result = await client.query(
492
- `SELECT * FROM ${SQL_TABLE[spec.table]} WHERE ${where.sql}${compileOrder(spec.order)}${limit}`,
493
- where.params
494
- );
495
- return result.rows.map((row) => rowToEntity(spec.table, row));
496
- },
497
- // ON CONFLICT DO NOTHING, which is the whole point: the refusal is the
498
- // DATABASE's, decided under the constraint, not a read the caller races.
499
- appendIfAbsent: async (table, input) => {
500
- await ready;
501
- const withId = tide.PRIMARY_KEY[table] === "id" ? { ...input, id: input.id ?? mintId(table) } : { ...input };
502
- const entries = Object.entries(withId).filter(([, value]) => value !== void 0);
503
- const columns = entries.map(([field]) => snake(field));
504
- const params = entries.map(([field, value]) => toColumn(snake(field), value));
505
- const unique = tide.UNIQUE_BY[table];
506
- const target = unique.when === void 0 ? `(${unique.by.map((column) => snake(String(column))).join(", ")})` : `(${unique.by.map((column) => column === "entity" || column === "name" ? `coalesce(${snake(String(column))},'')` : snake(String(column))).join(", ")}) WHERE ${snake(String(unique.when))} IS NOT NULL`;
507
- const result = await client.query(
508
- `INSERT INTO ${SQL_TABLE[table]} (${columns.join(", ")}) VALUES (${params.map((_value, index) => `$${index + 1}`).join(", ")})
509
- ON CONFLICT ${target} DO NOTHING RETURNING *`,
510
- params
511
- );
512
- const row = result.rows[0];
513
- return row === void 0 ? void 0 : rowToEntity(table, row);
514
- },
515
- // Selection and mutation in ONE statement. `FOR UPDATE SKIP LOCKED`
516
- // makes N instances ticking at once ordinary contention rather than a
517
- // lock service — it is a throughput choice; the exactly-once promise is
518
- // the single statement.
519
- claim: async (spec) => {
520
- await ready;
521
- const table = SQL_TABLE[spec.table];
522
- const order = compileOrder(spec.order, "c");
523
- const take = async (extra, limit) => {
524
- if (limit <= 0) return [];
525
- const where = compileWhere({ ...spec.where, ...extra }, 1, "c");
526
- const set = compileSet(spec.set, where.params.length + 1);
527
- const result = await client.query(
528
- `UPDATE ${table} SET ${set.sql}
529
- WHERE ctid IN (
530
- SELECT c.ctid FROM ${table} c WHERE ${where.sql}${order}
531
- LIMIT ${Math.floor(limit)} FOR UPDATE SKIP LOCKED
532
- )
533
- RETURNING *`,
534
- [...where.params, ...set.params]
535
- );
536
- return sortRows(result.rows.map((row) => rowToEntity(spec.table, row)), spec.order);
537
- };
538
- if (spec.onePer === void 0) return take({}, spec.limit);
539
- const { column, held, only } = spec.onePer;
540
- const restricted = [...only];
541
- const claimed = await take({ [String(column)]: { notIn: restricted } }, spec.limit - restricted.length);
542
- for (const group of restricted) {
543
- if (claimed.length >= spec.limit) break;
544
- const busy = compileWhere({ ...held, [String(column)]: group }, 1, "c");
545
- const taken = await client.query(`SELECT c.id FROM ${table} c WHERE ${busy.sql} LIMIT 1`, busy.params);
546
- if (taken.rows.length > 0) continue;
547
- claimed.push(...await take({ [String(column)]: group }, 1));
548
- }
549
- return claimed;
550
- },
551
- cas: async (table, id, expect, set) => {
552
- await ready;
553
- const key = snake(String(tide.PRIMARY_KEY[table]));
554
- const where = compileWhere(expect, 2);
555
- const patch = compileSet(set, where.params.length + 2);
556
- const result = await client.query(
557
- `UPDATE ${SQL_TABLE[table]} SET ${patch.sql} WHERE ${key} = $1 AND ${where.sql} RETURNING ${key}`,
558
- [id, ...where.params, ...patch.params]
559
- );
560
- return result.rows.length > 0;
561
- },
562
- remove: async (spec) => {
563
- await ready;
564
- const where = compileWhere(spec.where, 1);
565
- const result = await client.query(`DELETE FROM ${SQL_TABLE[spec.table]} WHERE ${where.sql} RETURNING ${snake(String(tide.PRIMARY_KEY[spec.table]))}`, where.params);
566
- return result.rows.length;
567
- },
568
- transact: async (fn) => {
569
- await ready;
570
- if (client.transaction === void 0)
571
- throw new Error("tide store: this pool cannot transact \u2014 fan-out and attempt recording are transactions, not conventions");
572
- return client.transaction((tx) => fn(build({ ...client, query: (text, values) => tx.query(text, values) })));
573
- }
574
- };
575
- return store;
576
- };
577
- return { ...build(pool), ready };
578
- };
579
- var mintWrites = async (intake, event, as, at, chain) => {
580
- for (const write of event.writes) {
581
- for (const row of write.rows) {
582
- await intake.ingest(
583
- { kind: "write", entity: write.table, op: write.op, row, at },
584
- { as, ...chain !== void 0 ? { cause: chain.cause, depth: chain.depth + 1 } : {} }
585
- );
586
- }
587
- }
588
- };
589
-
590
- // src/generation.ts
591
- var GENERATION_DDL = [
592
- /* sql */
593
- `CREATE TABLE IF NOT EXISTS moss_generation (id INT PRIMARY KEY, n BIGINT NOT NULL DEFAULT 0)`,
594
- /* sql */
595
- `INSERT INTO moss_generation (id, n) VALUES (1, 0) ON CONFLICT (id) DO NOTHING`
596
- ];
597
- var DEFAULT_GENERATION_POLL_MS = 60 * 1e3;
598
- var createGeneration = (pool, ctx) => {
599
- const everyMs = ctx.everyMs ?? DEFAULT_GENERATION_POLL_MS;
600
- let seen = -1;
601
- let checking = false;
602
- const read = async () => {
603
- if (checking) return;
604
- checking = true;
605
- try {
606
- const result = await pool.query("SELECT n FROM moss_generation WHERE id = 1");
607
- const n = Number(result.rows[0]?.n ?? 0);
608
- if (!Number.isFinite(n)) return;
609
- const first = seen === -1;
610
- const moved = !first && n !== seen;
611
- seen = n;
612
- if (moved) await ctx.onMoved();
613
- } catch (err) {
614
- console.error("[moss:generation] could not read the generation pointer \u2014 this process may be serving stale resolutions", err);
615
- } finally {
616
- checking = false;
617
- }
618
- };
619
- void read();
620
- const timer = everyMs > 0 ? setInterval(() => void read(), everyMs) : void 0;
621
- timer?.unref?.();
622
- return {
623
- bump: () => {
624
- void pool.query("UPDATE moss_generation SET n = n + 1 WHERE id = 1").then(async () => {
625
- const result = await pool.query("SELECT n FROM moss_generation WHERE id = 1");
626
- seen = Number(result.rows[0]?.n ?? seen);
627
- }).catch((err) => console.error("[moss:generation] could not move the pointer", err));
628
- },
629
- current: () => seen,
630
- stop: () => {
631
- if (timer !== void 0) clearInterval(timer);
632
- }
633
- };
634
- };
635
- var b64url = (buffer) => buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
636
- var fromB64url = (text) => Buffer.from(text.replace(/-/g, "+").replace(/_/g, "/"), "base64");
637
- var signerFromSeed = (seed) => {
638
- const pkcs8 = Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), seed.subarray(0, 32)]);
639
- const privateKey = crypto.createPrivateKey({ key: pkcs8, format: "der", type: "pkcs8" });
640
- const asInput = privateKey;
641
- return { privateKey, publicKey: crypto.createPublicKey(asInput) };
642
- };
643
- var createAssertionSigner = (seedB64) => {
644
- const seed = seedB64 !== void 0 && seedB64 !== "" ? Buffer.from(seedB64, "base64") : void 0;
645
- const { publicKey, privateKey } = seed !== void 0 && seed.length >= 32 ? signerFromSeed(seed) : crypto.generateKeyPairSync("ed25519");
646
- const verifyKey = publicKey.export({ type: "spki", format: "der" }).toString("base64");
647
- return {
648
- verifyKey,
649
- mint: (claims, ttlMs = 3e4) => {
650
- const iat = Date.now();
651
- const body = Buffer.from(JSON.stringify({ ...claims, iat, exp: iat + ttlMs }));
652
- return `${b64url(body)}.${b64url(crypto.sign(null, body, privateKey))}`;
653
- }
654
- };
655
- };
656
- var verifyAssertion = (token, verifyKey, now = Date.now()) => {
657
- const dot = token.indexOf(".");
658
- if (dot <= 0) return void 0;
659
- try {
660
- const body = fromB64url(token.slice(0, dot));
661
- const signature = fromB64url(token.slice(dot + 1));
662
- const key = crypto.createPublicKey({ key: fromB64url(verifyKey), format: "der", type: "spki" });
663
- if (!crypto.verify(null, body, key, signature)) return void 0;
664
- const parsed = JSON.parse(body.toString());
665
- if (typeof parsed.integration !== "string" || typeof parsed.principal !== "string") return void 0;
666
- if (typeof parsed.exp !== "number" || parsed.exp <= now) return void 0;
667
- return parsed;
668
- } catch {
669
- return void 0;
670
- }
671
- };
672
- var mintIntegrationKey = () => `ik_${crypto.randomBytes(32).toString("hex")}`;
673
- var hashIntegrationKey = (key) => crypto.createHash("sha256").update(key).digest("hex");
318
+ var mintIntegrationKey = () => `ik_${crypto$1.randomBytes(32).toString("hex")}`;
319
+ var hashIntegrationKey = (key) => crypto$1.createHash("sha256").update(key).digest("hex");
674
320
 
675
321
  // src/integrations.ts
676
322
  var configurationBase = {
@@ -1508,89 +1154,539 @@ var buildContract = (app, integrationId) => {
1508
1154
  const parts = String(entry).split(".");
1509
1155
  if (parts[0] === "ext" && parts[1] !== void 0 && parts[1] !== "*") audiences.add(parts[1]);
1510
1156
  }
1511
- }
1512
- const attachable = {};
1513
- for (const [action, offers] of Object.entries(app.attachable ?? {})) attachable[action] = Object.keys(offers);
1514
- return {
1515
- components,
1516
- audiences: [...audiences].sort(),
1517
- namespace: `ext.<audience>.${integrationId}.<name>`,
1518
- actionSchema: "nova ActionDefinition",
1519
- attachable,
1520
- menuSlots: [...app.menuSlots ?? []]
1157
+ }
1158
+ const attachable = {};
1159
+ for (const [action, offers] of Object.entries(app.attachable ?? {})) attachable[action] = Object.keys(offers);
1160
+ return {
1161
+ components,
1162
+ audiences: [...audiences].sort(),
1163
+ namespace: `ext.<audience>.${integrationId}.<name>`,
1164
+ actionSchema: "nova ActionDefinition",
1165
+ attachable,
1166
+ menuSlots: [...app.menuSlots ?? []]
1167
+ };
1168
+ };
1169
+ var describeProp = (schema) => {
1170
+ const enumValues = schema["enum"];
1171
+ if (Array.isArray(enumValues)) return `one of: ${enumValues.map((v) => String(v)).join(", ")}`;
1172
+ const anyOf = schema["anyOf"];
1173
+ if (Array.isArray(anyOf)) {
1174
+ const consts = anyOf.map((s) => s["const"]).filter((v) => v !== void 0);
1175
+ if (consts.length === anyOf.length && consts.length > 0) return `one of: ${consts.map((v) => String(v)).join(", ")}`;
1176
+ }
1177
+ const type = schema["type"];
1178
+ const base = typeof type === "string" ? type : Array.isArray(type) ? type.map((t) => String(t)).join(" | ") : "value";
1179
+ const min = schema["minimum"];
1180
+ const max = schema["maximum"];
1181
+ if (typeof min === "number" || typeof max === "number") return `${base} (${typeof min === "number" ? min : "\u2026"}\u2013${typeof max === "number" ? max : "\u2026"})`;
1182
+ return base;
1183
+ };
1184
+ var componentAsMarkdown = (component) => {
1185
+ const head = component.description !== "" ? `**${component.name}** \u2014 ${component.description}` : `**${component.name}**`;
1186
+ const schema = component.propsSchema;
1187
+ const properties = schema?.properties;
1188
+ if (properties === void 0 || Object.keys(properties).length === 0) return head;
1189
+ const required = new Set(schema?.required ?? []);
1190
+ const rows = Object.entries(properties).map(
1191
+ ([prop, spec]) => `| ${prop} | ${describeProp(spec)} | ${required.has(prop) ? "yes" : "no"} | ${String(spec["description"] ?? "")} |`
1192
+ );
1193
+ return [head, ``, `| prop | type | required | meaning |`, `| --- | --- | --- | --- |`, ...rows].join("\n");
1194
+ };
1195
+ var contractAsMarkdown = (contract, fingerprints) => [
1196
+ `# What you can build against`,
1197
+ ``,
1198
+ `## Your namespace`,
1199
+ ``,
1200
+ ` ${contract.namespace}`,
1201
+ ``,
1202
+ `Every action you ship must be named this way. Audiences available: ${contract.audiences.join(", ") || "(none)"}.`,
1203
+ ``,
1204
+ `## Components your layouts may use`,
1205
+ ``,
1206
+ contract.components.map(componentAsMarkdown).join("\n\n") || "(none)",
1207
+ ``,
1208
+ `## Fingerprints you may call`,
1209
+ ``,
1210
+ `Endpoints may target \`/api/<resource>/vex\` with one of these, or any URL under`,
1211
+ `\`/integrations/<your id>/\`. Nothing else.`,
1212
+ ``,
1213
+ fingerprints.map((f) => `- ${f}`).join("\n") || "(none \u2014 your grants reach nothing yet)",
1214
+ ``,
1215
+ `## Where your screens may appear`,
1216
+ ``,
1217
+ `Declare \`attachments\` (action \u2192 host action) to ride a host screen, and`,
1218
+ `\`placements\` (action \u2192 hub) to list under a menu hub. \`settings\` names the one`,
1219
+ `action the store tile opens. Anything else is refused.`,
1220
+ ``,
1221
+ `Attachable, with what each hands you as input:`,
1222
+ ``,
1223
+ Object.entries(contract.attachable).map(([action, offers]) => `- ${action} \u2014 offers ${offers.join(", ") || "(nothing)"}`).join("\n") || "(none)",
1224
+ ``,
1225
+ `Menu hubs accepting placements:`,
1226
+ ``,
1227
+ contract.menuSlots.map((hub) => `- ${hub}`).join("\n") || "(none)",
1228
+ ``,
1229
+ `## What you cannot ship`,
1230
+ ``,
1231
+ `- vex entries or mutations. Call what is listed above; if you need a read that`,
1232
+ ` does not exist, it is a change to the app.`,
1233
+ `- \`fn:\` endpoints. Those run in the app's process.`,
1234
+ `- components. Layouts compose what is listed above.`,
1235
+ `- tables. Bring your own storage; we hand you identifiers.`,
1236
+ ``
1237
+ ].join("\n");
1238
+
1239
+ // src/migrate.ts
1240
+ var tableSequencesOf = (runtime) => {
1241
+ const cacheSequence = (runtime.cache ?? vex.createPostgresCache({ pool: runtime.pool })).sequence;
1242
+ return [
1243
+ MOSS_SEQUENCE,
1244
+ ...runtime.session === "sessions" ? [SESSIONS_SEQUENCE] : [],
1245
+ ...cacheSequence === void 0 ? [] : [cacheSequence],
1246
+ ...runtime.tables ?? []
1247
+ ];
1248
+ };
1249
+ var misfitOf = (entry, schema) => {
1250
+ if (!("mutation" in entry)) {
1251
+ try {
1252
+ vex.resolve(vex.pruneOptional(entry.dsl, "all"), schema);
1253
+ return void 0;
1254
+ } catch (error) {
1255
+ return error instanceof Error ? error.message : String(error);
1256
+ }
1257
+ }
1258
+ return vex.mutationMisfits(entry.mutation, schema)[0];
1259
+ };
1260
+ var misfitsOf = (entries, schema) => {
1261
+ const misfits = /* @__PURE__ */ new Map();
1262
+ for (const entry of entries) {
1263
+ const why = misfitOf(entry, schema);
1264
+ if (why !== void 0) misfits.set(entry.fingerprint, why);
1265
+ }
1266
+ return misfits;
1267
+ };
1268
+ var canonical = (value) => {
1269
+ if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
1270
+ if (value === null || typeof value !== "object") return JSON.stringify(value);
1271
+ const keys = Object.keys(value).filter((key) => Reflect.get(value, key) !== void 0).sort();
1272
+ return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical(Reflect.get(value, key))}`).join(",")}}`;
1273
+ };
1274
+ var isSeededAs = async (cache, entry) => {
1275
+ const held = await cache.get(entry.fingerprint);
1276
+ if (held === void 0 || held.protected !== true) return false;
1277
+ if ("mutation" in entry) return held.kind === "mutation" && canonical(held.mutation) === canonical(entry.mutation);
1278
+ return held.kind === "ok" && canonical(held.dsl) === canonical(entry.dsl);
1279
+ };
1280
+ var changesBetween = (before, after) => {
1281
+ const removed = [];
1282
+ const retyped = [];
1283
+ for (const was of before.entities) {
1284
+ const now = after.entities.find((entity) => entity.table === was.table);
1285
+ if (now === void 0) {
1286
+ removed.push(was.table);
1287
+ continue;
1288
+ }
1289
+ for (const field of was.fields) {
1290
+ const kept = now.fields.find((f) => f.name === field.name);
1291
+ if (kept === void 0) removed.push(`${was.table}.${field.name}`);
1292
+ else if (kept.type !== field.type) retyped.push(`${was.table}.${field.name} (${field.type} \u2192 ${kept.type})`);
1293
+ }
1294
+ }
1295
+ return { removed, retyped };
1296
+ };
1297
+ var oneAtATime = (query) => {
1298
+ let last = Promise.resolve();
1299
+ return (text, values) => {
1300
+ const next = last.then(() => query(text, values));
1301
+ last = next.catch(() => void 0);
1302
+ return next;
1303
+ };
1304
+ };
1305
+ var migrateTables = async (runtime, app, options = {}) => {
1306
+ const entries = app.entries ?? [];
1307
+ const cache = runtime.cache ?? vex.createPostgresCache({ pool: runtime.pool });
1308
+ const before = await vex.createPostgresAdapter({ pool: runtime.pool }).introspect();
1309
+ const misfitsBefore = misfitsOf(entries, before);
1310
+ const excused = /* @__PURE__ */ new Set();
1311
+ for (const entry of entries) {
1312
+ if (misfitsBefore.has(entry.fingerprint) && await isSeededAs(cache, entry).catch(() => false)) excused.add(entry.fingerprint);
1313
+ }
1314
+ let found = { removed: [], retyped: [], alreadyBroken: [] };
1315
+ const report = await postgres.migrate(runtime.pool, tableSequencesOf(runtime), {
1316
+ ...options.dryRun === true ? { dryRun: true } : {},
1317
+ guard: async (tx) => {
1318
+ const after = await vex.createPostgresAdapter({ pool: { query: oneAtATime((text, values) => tx.query(text, values)) } }).introspect();
1319
+ const refused = [];
1320
+ const alreadyBroken = [];
1321
+ for (const [fingerprint, why] of misfitsOf(entries, after)) {
1322
+ if (excused.has(fingerprint)) alreadyBroken.push(`${fingerprint}: ${why}`);
1323
+ else refused.push(`${fingerprint}: ${why}`);
1324
+ }
1325
+ found = { ...changesBetween(before, after), alreadyBroken };
1326
+ return refused;
1327
+ }
1328
+ });
1329
+ return { ...report, ...found, ...report.applied.length === 0 ? { removed: [], retyped: [] } : {} };
1330
+ };
1331
+ var TIDE_TABLES = ["tide_fact", "tide_run", "tide_work", "tide_reflex_state"];
1332
+ var TIDE_DDL = `
1333
+ CREATE TABLE IF NOT EXISTS tide_fact (
1334
+ id text PRIMARY KEY,
1335
+ kind text NOT NULL CHECK (kind IN ('write','signal','manual','run')),
1336
+ entity text,
1337
+ op text CHECK (op IN ('insert','update','delete')),
1338
+ row jsonb,
1339
+ name text,
1340
+ payload jsonb,
1341
+ reflex text,
1342
+ run_id text,
1343
+ occurrence text,
1344
+ stats jsonb,
1345
+ target text,
1346
+ by text,
1347
+ at bigint NOT NULL,
1348
+ not_before bigint,
1349
+ dedupe_key text,
1350
+ cause text,
1351
+ depth integer NOT NULL DEFAULT 0,
1352
+ delivered_at bigint,
1353
+ parked text,
1354
+ released boolean,
1355
+ -- WHOSE FACT THIS IS. The identity of the reflex that minted it, absent on
1356
+ -- anything the host ingested. The matcher refuses to hand a fact minted
1357
+ -- under one identity to a reflex running under another, which is the only
1358
+ -- thing standing between a carried row and somebody else's effect \u2014 tide is
1359
+ -- the one place a row travels without being read, so no scope policy is
1360
+ -- consulted on the way.
1361
+ as_who text
1362
+ );
1363
+
1364
+ -- A PARTIAL index, because a fact with no dedupeKey is not claiming to be
1365
+ -- unique: it is a distinct occurrence of something, not a repeat of it.
1366
+ -- entity is in the key: without it, two producers over different tables
1367
+ -- that agreed on a key value silently ate each other's rows.
1368
+ CREATE UNIQUE INDEX IF NOT EXISTS tide_fact_dedupe
1369
+ ON tide_fact (kind, coalesce(entity,''), coalesce(name,''), dedupe_key)
1370
+ WHERE dedupe_key IS NOT NULL;
1371
+
1372
+ -- The matcher's query, every advance.
1373
+ CREATE INDEX IF NOT EXISTS tide_fact_due
1374
+ ON tide_fact (at) WHERE delivered_at IS NULL AND parked IS NULL;
1375
+ CREATE INDEX IF NOT EXISTS tide_fact_swept ON tide_fact (delivered_at);
1376
+
1377
+ CREATE TABLE IF NOT EXISTS tide_run (
1378
+ id text PRIMARY KEY,
1379
+ reflex_id text NOT NULL,
1380
+ version text NOT NULL,
1381
+ as_who text,
1382
+ cause text NOT NULL,
1383
+ occurrence text,
1384
+ fact_ids jsonb,
1385
+ state text NOT NULL CHECK (state IN ('pending','fanned','settled','skipped')),
1386
+ depth integer NOT NULL DEFAULT 0,
1387
+ selected integer,
1388
+ total integer NOT NULL DEFAULT 0,
1389
+ done integer NOT NULL DEFAULT 0,
1390
+ failed integer NOT NULL DEFAULT 0,
1391
+ due_at bigint NOT NULL,
1392
+ created_at bigint NOT NULL,
1393
+ settled_at bigint,
1394
+ drained boolean,
1395
+ note text,
1396
+ -- THE IDEMPOTENCY. One constraint, every trigger kind: an occurrence
1397
+ -- cannot open twice, a replayed fact cannot open twice, and two instances
1398
+ -- ticking at the same moment contend instead of duplicating.
1399
+ UNIQUE (reflex_id, cause)
1400
+ );
1401
+
1402
+ CREATE INDEX IF NOT EXISTS tide_run_pending ON tide_run (state, due_at);
1403
+ CREATE INDEX IF NOT EXISTS tide_run_ledger ON tide_run (reflex_id, created_at DESC);
1404
+ CREATE INDEX IF NOT EXISTS tide_run_swept ON tide_run (settled_at);
1405
+
1406
+ CREATE TABLE IF NOT EXISTS tide_work (
1407
+ id text PRIMARY KEY,
1408
+ -- ON DELETE CASCADE, because a run and its work are one fact about the
1409
+ -- world. Sweeping runs and leaving work destroys the UNIQUE(run_id, unit)
1410
+ -- row that IS the "this unit already ran" record \u2014 and a restore then
1411
+ -- re-charges the invoice.
1412
+ run_id text NOT NULL REFERENCES tide_run(id) ON DELETE CASCADE,
1413
+ reflex_id text NOT NULL,
1414
+ unit text NOT NULL,
1415
+ cause text NOT NULL,
1416
+ env jsonb NOT NULL,
1417
+ depth integer NOT NULL DEFAULT 0,
1418
+ state text NOT NULL CHECK (state IN ('pending','claimed','retrying','done','failed')),
1419
+ attempt integer NOT NULL DEFAULT 0,
1420
+ token text,
1421
+ -- Zero, never null, when unclaimed: "never claimed or lapsed" is then one
1422
+ -- comparison rather than a disjunction.
1423
+ claimed_until bigint NOT NULL DEFAULT 0,
1424
+ not_before bigint NOT NULL,
1425
+ input jsonb,
1426
+ output jsonb,
1427
+ error text,
1428
+ created_at bigint NOT NULL,
1429
+ settled_at bigint,
1430
+ UNIQUE (run_id, unit)
1431
+ );
1432
+
1433
+ CREATE INDEX IF NOT EXISTS tide_work_claimable ON tide_work (state, not_before, claimed_until);
1434
+ CREATE INDEX IF NOT EXISTS tide_work_run ON tide_work (run_id);
1435
+ CREATE INDEX IF NOT EXISTS tide_work_swept ON tide_work (settled_at);
1436
+
1437
+ CREATE TABLE IF NOT EXISTS tide_reflex_state (
1438
+ reflex_id text PRIMARY KEY,
1439
+ armed_at bigint NOT NULL DEFAULT 0,
1440
+ materialized_through bigint
1441
+ );
1442
+
1443
+ -- Polls are gone (the vex bridge pushes writes \u2014 a poll could only
1444
+ -- re-discover them late), and their cursor state goes with them. IF EXISTS,
1445
+ -- so a store created after the removal is not asked to drop what it never had.
1446
+ ALTER TABLE tide_reflex_state DROP COLUMN IF EXISTS poll_cursor;
1447
+ ALTER TABLE tide_reflex_state DROP COLUMN IF EXISTS poll_seen;
1448
+ ALTER TABLE tide_reflex_state DROP COLUMN IF EXISTS polled_at;
1449
+ `;
1450
+ var SQL_TABLE = {
1451
+ fact: "tide_fact",
1452
+ run: "tide_run",
1453
+ task: "tide_work",
1454
+ state: "tide_reflex_state"
1455
+ };
1456
+ var COLUMN_OVERRIDES = { as: "as_who" };
1457
+ var snake = (field) => COLUMN_OVERRIDES[field] ?? field.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
1458
+ var camel = (column) => {
1459
+ for (const [field, mapped] of Object.entries(COLUMN_OVERRIDES)) if (mapped === column) return field;
1460
+ return column.replace(/_([a-z])/g, (_all, c) => c.toUpperCase());
1461
+ };
1462
+ var JSON_COLUMNS = /* @__PURE__ */ new Set(["row", "payload", "stats", "fact_ids", "env", "input", "output"]);
1463
+ var BIGINT_COLUMNS = /* @__PURE__ */ new Set([
1464
+ "at",
1465
+ "not_before",
1466
+ "delivered_at",
1467
+ "depth",
1468
+ "descendants",
1469
+ "due_at",
1470
+ "created_at",
1471
+ "settled_at",
1472
+ "claimed_until",
1473
+ "armed_at",
1474
+ "materialized_through",
1475
+ "attempt",
1476
+ "selected",
1477
+ "total",
1478
+ "done",
1479
+ "failed"
1480
+ ]);
1481
+ var toColumn = (column, value) => {
1482
+ if (value === void 0) return null;
1483
+ if (JSON_COLUMNS.has(column)) return JSON.stringify(value);
1484
+ return value;
1485
+ };
1486
+ var fromColumn = (column, value) => {
1487
+ if (value === null) return void 0;
1488
+ if (JSON_COLUMNS.has(column)) return typeof value === "string" ? JSON.parse(value) : value;
1489
+ if (BIGINT_COLUMNS.has(column)) return Number(value);
1490
+ return value;
1491
+ };
1492
+ var rowToEntity = (table, row) => {
1493
+ const entity = {};
1494
+ for (const [column, value] of Object.entries(row)) {
1495
+ const mapped = fromColumn(column, value);
1496
+ if (mapped !== void 0) entity[camel(column)] = mapped;
1497
+ }
1498
+ return entity;
1499
+ };
1500
+ var COMPARATORS = { eq: "=", ne: "<>", lt: "<", lte: "<=", gt: ">", gte: ">=" };
1501
+ var compileWhere = (where, start, alias = "") => {
1502
+ const clauses = [];
1503
+ const params = [];
1504
+ const prefix = alias === "" ? "" : `${alias}.`;
1505
+ const slot = (value) => {
1506
+ params.push(value);
1507
+ return `$${start + params.length - 1}`;
1508
+ };
1509
+ for (const [field, test] of Object.entries(where ?? {})) {
1510
+ const column = `${prefix}${snake(field)}`;
1511
+ const bare = snake(field);
1512
+ if (test === null || typeof test !== "object" || Array.isArray(test)) {
1513
+ clauses.push(test === void 0 ? `${column} IS NULL` : `${column} = ${slot(toColumn(bare, test))}`);
1514
+ continue;
1515
+ }
1516
+ const comparison = test;
1517
+ for (const [op, symbol] of Object.entries(COMPARATORS)) {
1518
+ const operand = comparison[op];
1519
+ if (operand === void 0) continue;
1520
+ clauses.push(op === "ne" ? `(${column} IS NULL OR ${column} <> ${slot(toColumn(bare, operand))})` : `${column} ${symbol} ${slot(toColumn(bare, operand))}`);
1521
+ }
1522
+ if (comparison.in !== void 0) clauses.push(`${column} = ANY(${slot(comparison.in.map((value) => toColumn(bare, value)))})`);
1523
+ if (comparison.notIn !== void 0) clauses.push(`NOT (${column} = ANY(${slot(comparison.notIn.map((value) => toColumn(bare, value)))}))`);
1524
+ if (comparison.isNull !== void 0) clauses.push(comparison.isNull ? `${column} IS NULL` : `${column} IS NOT NULL`);
1525
+ }
1526
+ return { sql: clauses.length === 0 ? "TRUE" : clauses.join(" AND "), params };
1527
+ };
1528
+ var compileOrder = (order, alias = "") => {
1529
+ if (order === void 0 || order.length === 0) return "";
1530
+ const prefix = alias === "" ? "" : `${alias}.`;
1531
+ return ` ORDER BY ${order.map((key) => `${prefix}${snake(String(key.by))} ${key.dir === "desc" ? "DESC" : "ASC"}`).join(", ")}`;
1532
+ };
1533
+ var sortRows = (rows, order) => {
1534
+ if (order === void 0 || order.length === 0) return [...rows];
1535
+ return [...rows].sort((left, right) => {
1536
+ for (const key of order) {
1537
+ const a = left[String(key.by)];
1538
+ const b = right[String(key.by)];
1539
+ const compared = typeof a === "number" && typeof b === "number" ? a - b : String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
1540
+ if (compared !== 0) return compared * (key.dir === "desc" ? -1 : 1);
1541
+ }
1542
+ return 0;
1543
+ });
1544
+ };
1545
+ var compileSet = (set, start) => {
1546
+ const assignments = [];
1547
+ const params = [];
1548
+ for (const [field, value] of Object.entries(set)) {
1549
+ const column = snake(field);
1550
+ if (value !== null && typeof value === "object" && "inc" in value) {
1551
+ assignments.push(`${column} = coalesce(${column}, 0) + ${Number(value.inc)}`);
1552
+ continue;
1553
+ }
1554
+ params.push(toColumn(column, value));
1555
+ assignments.push(`${column} = $${start + params.length - 1}`);
1556
+ }
1557
+ return { sql: assignments.join(", "), params };
1558
+ };
1559
+ var mintId = /* @__PURE__ */ (() => {
1560
+ let sequence = 0;
1561
+ return (table) => {
1562
+ sequence += 1;
1563
+ return `${table}_${Date.now().toString(36)}_${sequence.toString(36)}`;
1564
+ };
1565
+ })();
1566
+ var statementsOf = (ddl) => ddl.split(";").map((chunk) => chunk.trim()).filter((chunk) => chunk.split("\n").some((line) => line.trim() !== "" && !line.trim().startsWith("--"))).map((sql) => ({ kind: "sql", sql }));
1567
+ var TIDE_SEQUENCE = {
1568
+ id: "nisc.moss.tide",
1569
+ migrations: [
1570
+ { description: "The tide store: facts, runs, work and reflex state, converged from any earlier shape", steps: statementsOf(TIDE_DDL) },
1571
+ {
1572
+ // A fact's chain: the root it belongs to, and — on a root — how many facts
1573
+ // the chain has minted beneath it. Nullable: every existing fact is a
1574
+ // root nothing has been counted against yet.
1575
+ description: "A fact carries its chain root, and a root counts what its chain minted (tide maxChainFacts)",
1576
+ steps: [
1577
+ { kind: "sql", sql: "ALTER TABLE tide_fact ADD COLUMN IF NOT EXISTS root text" },
1578
+ { kind: "sql", sql: "ALTER TABLE tide_fact ADD COLUMN IF NOT EXISTS descendants integer" }
1579
+ ]
1580
+ }
1581
+ ]
1582
+ };
1583
+ var createTideStore = (pool, options = {}) => {
1584
+ const ready = options.migrate === false ? Promise.resolve() : postgres.migrate(pool, [TIDE_SEQUENCE]).then(() => void 0);
1585
+ ready.catch(() => void 0);
1586
+ const build = (client) => {
1587
+ const store = {
1588
+ query: async (spec) => {
1589
+ await ready;
1590
+ const where = compileWhere(spec.where, 1);
1591
+ const limit = spec.limit === void 0 ? "" : ` LIMIT ${Math.max(0, Math.floor(spec.limit))}`;
1592
+ const result = await client.query(
1593
+ `SELECT * FROM ${SQL_TABLE[spec.table]} WHERE ${where.sql}${compileOrder(spec.order)}${limit}`,
1594
+ where.params
1595
+ );
1596
+ return result.rows.map((row) => rowToEntity(spec.table, row));
1597
+ },
1598
+ // ON CONFLICT DO NOTHING, which is the whole point: the refusal is the
1599
+ // DATABASE's, decided under the constraint, not a read the caller races.
1600
+ appendIfAbsent: async (table, input) => {
1601
+ await ready;
1602
+ const withId = tide.PRIMARY_KEY[table] === "id" ? { ...input, id: input.id ?? mintId(table) } : { ...input };
1603
+ const entries = Object.entries(withId).filter(([, value]) => value !== void 0);
1604
+ const columns = entries.map(([field]) => snake(field));
1605
+ const params = entries.map(([field, value]) => toColumn(snake(field), value));
1606
+ const unique = tide.UNIQUE_BY[table];
1607
+ const target = unique.when === void 0 ? `(${unique.by.map((column) => snake(String(column))).join(", ")})` : `(${unique.by.map((column) => column === "entity" || column === "name" ? `coalesce(${snake(String(column))},'')` : snake(String(column))).join(", ")}) WHERE ${snake(String(unique.when))} IS NOT NULL`;
1608
+ const result = await client.query(
1609
+ `INSERT INTO ${SQL_TABLE[table]} (${columns.join(", ")}) VALUES (${params.map((_value, index) => `$${index + 1}`).join(", ")})
1610
+ ON CONFLICT ${target} DO NOTHING RETURNING *`,
1611
+ params
1612
+ );
1613
+ const row = result.rows[0];
1614
+ return row === void 0 ? void 0 : rowToEntity(table, row);
1615
+ },
1616
+ // Selection and mutation in ONE statement. `FOR UPDATE SKIP LOCKED`
1617
+ // makes N instances ticking at once ordinary contention rather than a
1618
+ // lock service — it is a throughput choice; the exactly-once promise is
1619
+ // the single statement.
1620
+ claim: async (spec) => {
1621
+ await ready;
1622
+ const table = SQL_TABLE[spec.table];
1623
+ const order = compileOrder(spec.order, "c");
1624
+ const take = async (extra, limit) => {
1625
+ if (limit <= 0) return [];
1626
+ const where = compileWhere({ ...spec.where, ...extra }, 1, "c");
1627
+ const set = compileSet(spec.set, where.params.length + 1);
1628
+ const result = await client.query(
1629
+ `UPDATE ${table} SET ${set.sql}
1630
+ WHERE ctid IN (
1631
+ SELECT c.ctid FROM ${table} c WHERE ${where.sql}${order}
1632
+ LIMIT ${Math.floor(limit)} FOR UPDATE SKIP LOCKED
1633
+ )
1634
+ RETURNING *`,
1635
+ [...where.params, ...set.params]
1636
+ );
1637
+ return sortRows(result.rows.map((row) => rowToEntity(spec.table, row)), spec.order);
1638
+ };
1639
+ if (spec.onePer === void 0) return take({}, spec.limit);
1640
+ const { column, held, only } = spec.onePer;
1641
+ const restricted = [...only];
1642
+ const claimed = await take({ [String(column)]: { notIn: restricted } }, spec.limit - restricted.length);
1643
+ for (const group of restricted) {
1644
+ if (claimed.length >= spec.limit) break;
1645
+ const busy = compileWhere({ ...held, [String(column)]: group }, 1, "c");
1646
+ const taken = await client.query(`SELECT c.id FROM ${table} c WHERE ${busy.sql} LIMIT 1`, busy.params);
1647
+ if (taken.rows.length > 0) continue;
1648
+ claimed.push(...await take({ [String(column)]: group }, 1));
1649
+ }
1650
+ return claimed;
1651
+ },
1652
+ cas: async (table, id, expect, set) => {
1653
+ await ready;
1654
+ const key = snake(String(tide.PRIMARY_KEY[table]));
1655
+ const where = compileWhere(expect, 2);
1656
+ const patch = compileSet(set, where.params.length + 2);
1657
+ const result = await client.query(
1658
+ `UPDATE ${SQL_TABLE[table]} SET ${patch.sql} WHERE ${key} = $1 AND ${where.sql} RETURNING ${key}`,
1659
+ [id, ...where.params, ...patch.params]
1660
+ );
1661
+ return result.rows.length > 0;
1662
+ },
1663
+ remove: async (spec) => {
1664
+ await ready;
1665
+ const where = compileWhere(spec.where, 1);
1666
+ const result = await client.query(`DELETE FROM ${SQL_TABLE[spec.table]} WHERE ${where.sql} RETURNING ${snake(String(tide.PRIMARY_KEY[spec.table]))}`, where.params);
1667
+ return result.rows.length;
1668
+ },
1669
+ transact: async (fn) => {
1670
+ await ready;
1671
+ if (client.transaction === void 0)
1672
+ throw new Error("tide store: this pool cannot transact \u2014 fan-out and attempt recording are transactions, not conventions");
1673
+ return client.transaction((tx) => fn(build({ ...client, query: (text, values) => tx.query(text, values) })));
1674
+ }
1675
+ };
1676
+ return store;
1521
1677
  };
1678
+ return { ...build(pool), ready };
1522
1679
  };
1523
- var describeProp = (schema) => {
1524
- const enumValues = schema["enum"];
1525
- if (Array.isArray(enumValues)) return `one of: ${enumValues.map((v) => String(v)).join(", ")}`;
1526
- const anyOf = schema["anyOf"];
1527
- if (Array.isArray(anyOf)) {
1528
- const consts = anyOf.map((s) => s["const"]).filter((v) => v !== void 0);
1529
- if (consts.length === anyOf.length && consts.length > 0) return `one of: ${consts.map((v) => String(v)).join(", ")}`;
1680
+ var mintWrites = async (intake, event, as, at, chain) => {
1681
+ for (const write of event.writes) {
1682
+ for (const row of write.rows) {
1683
+ await intake.ingest(
1684
+ { kind: "write", entity: write.table, op: write.op, row, at },
1685
+ { as, ...chain !== void 0 ? { cause: chain.cause, depth: chain.depth + 1 } : {} }
1686
+ );
1687
+ }
1530
1688
  }
1531
- const type = schema["type"];
1532
- const base = typeof type === "string" ? type : Array.isArray(type) ? type.map((t) => String(t)).join(" | ") : "value";
1533
- const min = schema["minimum"];
1534
- const max = schema["maximum"];
1535
- if (typeof min === "number" || typeof max === "number") return `${base} (${typeof min === "number" ? min : "\u2026"}\u2013${typeof max === "number" ? max : "\u2026"})`;
1536
- return base;
1537
- };
1538
- var componentAsMarkdown = (component) => {
1539
- const head = component.description !== "" ? `**${component.name}** \u2014 ${component.description}` : `**${component.name}**`;
1540
- const schema = component.propsSchema;
1541
- const properties = schema?.properties;
1542
- if (properties === void 0 || Object.keys(properties).length === 0) return head;
1543
- const required = new Set(schema?.required ?? []);
1544
- const rows = Object.entries(properties).map(
1545
- ([prop, spec]) => `| ${prop} | ${describeProp(spec)} | ${required.has(prop) ? "yes" : "no"} | ${String(spec["description"] ?? "")} |`
1546
- );
1547
- return [head, ``, `| prop | type | required | meaning |`, `| --- | --- | --- | --- |`, ...rows].join("\n");
1548
1689
  };
1549
- var contractAsMarkdown = (contract, fingerprints) => [
1550
- `# What you can build against`,
1551
- ``,
1552
- `## Your namespace`,
1553
- ``,
1554
- ` ${contract.namespace}`,
1555
- ``,
1556
- `Every action you ship must be named this way. Audiences available: ${contract.audiences.join(", ") || "(none)"}.`,
1557
- ``,
1558
- `## Components your layouts may use`,
1559
- ``,
1560
- contract.components.map(componentAsMarkdown).join("\n\n") || "(none)",
1561
- ``,
1562
- `## Fingerprints you may call`,
1563
- ``,
1564
- `Endpoints may target \`/api/<resource>/vex\` with one of these, or any URL under`,
1565
- `\`/integrations/<your id>/\`. Nothing else.`,
1566
- ``,
1567
- fingerprints.map((f) => `- ${f}`).join("\n") || "(none \u2014 your grants reach nothing yet)",
1568
- ``,
1569
- `## Where your screens may appear`,
1570
- ``,
1571
- `Declare \`attachments\` (action \u2192 host action) to ride a host screen, and`,
1572
- `\`placements\` (action \u2192 hub) to list under a menu hub. \`settings\` names the one`,
1573
- `action the store tile opens. Anything else is refused.`,
1574
- ``,
1575
- `Attachable, with what each hands you as input:`,
1576
- ``,
1577
- Object.entries(contract.attachable).map(([action, offers]) => `- ${action} \u2014 offers ${offers.join(", ") || "(nothing)"}`).join("\n") || "(none)",
1578
- ``,
1579
- `Menu hubs accepting placements:`,
1580
- ``,
1581
- contract.menuSlots.map((hub) => `- ${hub}`).join("\n") || "(none)",
1582
- ``,
1583
- `## What you cannot ship`,
1584
- ``,
1585
- `- vex entries or mutations. Call what is listed above; if you need a read that`,
1586
- ` does not exist, it is a change to the app.`,
1587
- `- \`fn:\` endpoints. Those run in the app's process.`,
1588
- `- components. Layouts compose what is listed above.`,
1589
- `- tables. Bring your own storage; we hand you identifiers.`,
1590
- ``
1591
- ].join("\n");
1592
-
1593
- // src/principal.ts
1594
1690
  var resolveRoles = (app, principal) => principal === null ? ["public"] : app.assignments?.[principal] ?? ["public"];
1595
1691
  var wearableOf = (app) => {
1596
1692
  const declared = app.wearable;
@@ -1686,8 +1782,101 @@ var versionToken = (ids) => {
1686
1782
  }
1687
1783
  return h.toString(16).padStart(8, "0");
1688
1784
  };
1689
- var PROTOCOL = 1;
1690
- var PROTOCOL_MIN = 1;
1785
+
1786
+ // src/session-cookie.ts
1787
+ var DEFAULT_TOKEN_KEY = "nisc.token";
1788
+ var tokenFromCookie = (header, name = DEFAULT_TOKEN_KEY) => {
1789
+ if (header === void 0 || header === null) return null;
1790
+ const wanted = encodeURIComponent(name);
1791
+ for (const part of header.split(";")) {
1792
+ const at = part.indexOf("=");
1793
+ if (at < 0 || part.slice(0, at).trim() !== wanted) continue;
1794
+ try {
1795
+ const value = decodeURIComponent(part.slice(at + 1).trim());
1796
+ return value === "" ? null : value;
1797
+ } catch {
1798
+ return null;
1799
+ }
1800
+ }
1801
+ return null;
1802
+ };
1803
+ var isOwnOrigin = (origin, host, listed = []) => {
1804
+ if (origin === void 0 || origin === null || !URL.canParse(origin)) return false;
1805
+ const asked = new URL(origin);
1806
+ return asked.host === host?.toLowerCase() || listed.some((entry) => URL.canParse(entry) && new URL(entry).origin === asked.origin);
1807
+ };
1808
+ var nameOf = (key, port) => `${key}${port === "" ? "" : `.${port}`}`;
1809
+ var cookiesAt = (where, key, token, lastsMs) => {
1810
+ const name = encodeURIComponent(nameOf(key, where.port));
1811
+ const life = token === null ? "; Max-Age=0" : typeof lastsMs === "number" ? `; Max-Age=${Math.max(0, Math.floor(lastsMs / 1e3))}` : "";
1812
+ const kept = `Path=/; SameSite=Lax${where.secure ? "; Secure" : ""}${life}`;
1813
+ return [`${where.secure ? "__Host-" : ""}${name}=${encodeURIComponent(token ?? "")}; HttpOnly; ${kept}`, `${name}.held=${token === null ? "" : "1"}; ${kept}`];
1814
+ };
1815
+ var originOf = (request) => {
1816
+ const said = request.headers.get("origin");
1817
+ if (said !== null && URL.canParse(said)) return said;
1818
+ const here = new URL(request.url);
1819
+ const scheme = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim() || here.protocol.slice(0, -1);
1820
+ return `${scheme}://${request.headers.get("host") ?? here.host}`;
1821
+ };
1822
+ var sessionCookies = (page, token, options = {}) => {
1823
+ const at = new URL(typeof page === "string" ? page : originOf(page));
1824
+ return cookiesAt({ port: at.port, secure: at.protocol === "https:" }, options.key ?? DEFAULT_TOKEN_KEY, token, options.lastsMs);
1825
+ };
1826
+ var sessionTokenOf = (cookies, where, key = DEFAULT_TOKEN_KEY) => {
1827
+ const name = nameOf(key, where.port);
1828
+ for (const secure of where.secure === void 0 ? [true, false] : [where.secure]) {
1829
+ const token = tokenFromCookie(cookies, `${secure ? "__Host-" : ""}${name}`);
1830
+ if (token !== null) return { token, clear: cookiesAt({ port: where.port, secure }, key, null) };
1831
+ }
1832
+ return null;
1833
+ };
1834
+ var SEALED_FOR_MS = 6e4;
1835
+ var sealName = (secure) => `${secure ? "__Http-" : ""}nisc.seal`;
1836
+ var toBase64Url = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
1837
+ var fromBase64Url = (text) => Uint8Array.from(atob(text.replace(/-/g, "+").replace(/_/g, "/")), (char) => char.charCodeAt(0));
1838
+ var keyOf = async (seal) => crypto.subtle.importKey("raw", await crypto.subtle.digest("SHA-256", new TextEncoder().encode(seal)), "AES-GCM", false, ["encrypt", "decrypt"]);
1839
+ var newSeal = () => toBase64Url(crypto.getRandomValues(new Uint8Array(32)));
1840
+ var sealOf = (cookies, secure) => tokenFromCookie(cookies, sealName(secure));
1841
+ var sealCookie = (seal, where) => `${sealName(where.secure)}=${seal}; HttpOnly; Path=${where.path}; SameSite=Lax${where.secure ? "; Secure" : ""}`;
1842
+ var sealSession = async (seal, token, forMs = SEALED_FOR_MS) => {
1843
+ const iv = crypto.getRandomValues(new Uint8Array(12));
1844
+ const sealed = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, await keyOf(seal), new TextEncoder().encode(JSON.stringify({ token, until: Date.now() + forMs })));
1845
+ return toBase64Url(new Uint8Array([...iv, ...new Uint8Array(sealed)]));
1846
+ };
1847
+ var openSealed = async (seal, sealed) => {
1848
+ try {
1849
+ const bytes = fromBase64Url(sealed);
1850
+ const opened = await crypto.subtle.decrypt({ name: "AES-GCM", iv: bytes.slice(0, 12) }, await keyOf(seal), bytes.slice(12));
1851
+ const { token, until } = JSON.parse(new TextDecoder().decode(opened));
1852
+ return typeof token === "string" && typeof until === "number" && until > Date.now() ? token : null;
1853
+ } catch {
1854
+ return null;
1855
+ }
1856
+ };
1857
+
1858
+ // src/socket.ts
1859
+ var PROTOCOL = 2;
1860
+ var PROTOCOL_MIN = 2;
1861
+ var SUBPROTOCOL = "nisc";
1862
+ var TOKEN_OFFER = "nisc.token.";
1863
+ var SEALED_OFFER = "nisc.sealed.";
1864
+ var offerToken = (token, sealed = null) => {
1865
+ const offer = sealed === null ? [SUBPROTOCOL] : [SUBPROTOCOL, `${SEALED_OFFER}${sealed}`];
1866
+ if (token === null) return offer;
1867
+ const bytes = String.fromCharCode(...new TextEncoder().encode(token));
1868
+ return [...offer, `${TOKEN_OFFER}${btoa(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`];
1869
+ };
1870
+ var offeredToken = (offered = []) => {
1871
+ const offer = offered.find((entry) => entry.startsWith(TOKEN_OFFER));
1872
+ if (offer === void 0) return null;
1873
+ try {
1874
+ const bytes = atob(offer.slice(TOKEN_OFFER.length).replace(/-/g, "+").replace(/_/g, "/"));
1875
+ return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes, (char) => char.charCodeAt(0))) || null;
1876
+ } catch {
1877
+ return null;
1878
+ }
1879
+ };
1691
1880
  var CLOSE_INVALID_TOKEN = 4401;
1692
1881
  var CLOSE_SIGNED_OUT = 4403;
1693
1882
  var CLOSE_SHELL_FAILED = 4500;
@@ -1703,6 +1892,7 @@ var parse = (text) => {
1703
1892
  };
1704
1893
  var createSocket = (ctx) => {
1705
1894
  const emit = emitterOf(ctx.telemetry);
1895
+ let saidNotOwn = false;
1706
1896
  const live = /* @__PURE__ */ new Map();
1707
1897
  const expire = (connection) => {
1708
1898
  connection.send(JSON.stringify({ type: "error", code: "invalid_token", message: "The session token no longer resolves to this principal." }));
@@ -1759,18 +1949,40 @@ var createSocket = (ctx) => {
1759
1949
  connection.close(CLOSE_PROTOCOL_MISMATCH, "protocol mismatch");
1760
1950
  return;
1761
1951
  }
1762
- const token = params.get("token");
1763
- let principal = null;
1764
- if (token !== null && token !== "") {
1765
- principal = await ctx.session(token);
1766
- if (principal === null) {
1767
- if (emit !== void 0 && upClock !== void 0) {
1768
- emit({ name: "socket.upgrade", startUnixNano: upClock.startUnixNano, endUnixNano: upClock.endUnixNano(), status: "refused", attributes: { hasPrincipal: false } });
1769
- }
1770
- send({ type: "error", code: "invalid_token", message: "The session token did not resolve to a principal." });
1771
- connection.close(CLOSE_INVALID_TOKEN, "invalid token");
1772
- return;
1952
+ const upgrade = connection.upgrade;
1953
+ const key = /^[\w.-]{1,64}$/.test(params.get("key") ?? "") ? params.get("key") : DEFAULT_TOKEN_KEY;
1954
+ const page = upgrade !== void 0 && isOwnOrigin(upgrade.origin, upgrade.host, ctx.origins) ? new URL(upgrade.origin) : void 0;
1955
+ const secure = page?.protocol === "https:";
1956
+ const held = page === void 0 ? null : sessionTokenOf(upgrade?.cookie, { port: page.port, secure }, key);
1957
+ const sealing = page !== void 0 && params.get("sealed") === "1";
1958
+ if (page === void 0 && params.get("sealed") === "1" && typeof upgrade?.origin === "string" && !saidNotOwn) {
1959
+ saidNotOwn = true;
1960
+ console.warn(`[moss] a terminal on ${upgrade.origin} holds its own session token: this server was addressed as ${upgrade.host ?? "nothing"}, so that is not the app\u2019s own page. If the app is served there, behind a proxy that rewrites Host, list it in runtime.origins.`);
1961
+ }
1962
+ const hadSeal = sealing ? sealOf(upgrade?.cookie, secure) : null;
1963
+ const sealedOffer = upgrade?.offered.find((entry) => entry.startsWith(SEALED_OFFER))?.slice(SEALED_OFFER.length) ?? null;
1964
+ const sealLost = sealing && sealedOffer !== null && hadSeal === null;
1965
+ const seal = !sealing || sealLost ? null : hadSeal ?? (upgrade?.answer === void 0 ? null : newSeal());
1966
+ const offered = offeredToken(upgrade?.offered) ?? (sealedOffer === null || hadSeal === null ? null : await openSealed(hadSeal, sealedOffer));
1967
+ let token = offered ?? (params.get("leave") === "1" ? null : held?.token ?? null);
1968
+ let principal = token === null ? null : await ctx.session(token);
1969
+ if (offered !== null && principal === null) {
1970
+ if (emit !== void 0 && upClock !== void 0) {
1971
+ emit({ name: "socket.upgrade", startUnixNano: upClock.startUnixNano, endUnixNano: upClock.endUnixNano(), status: "refused", attributes: { hasPrincipal: false } });
1773
1972
  }
1973
+ send({ type: "error", code: "invalid_token", message: "The session token did not resolve to a principal." });
1974
+ connection.close(CLOSE_INVALID_TOKEN, "invalid token");
1975
+ return;
1976
+ }
1977
+ if (principal === null) token = null;
1978
+ const answered = [
1979
+ ...page === void 0 || offered === null && (held?.token ?? null) === token ? [] : token === null ? held?.clear ?? [] : sessionCookies(page.origin, token, { key, lastsMs: await ctx.sessionLastsMs?.(token) ?? null }),
1980
+ ...seal !== null && hadSeal === null ? [sealCookie(seal, { secure, path: new URL(url, "http://nisc.local").pathname })] : []
1981
+ ];
1982
+ if (answered.length > 0) upgrade?.answer?.(answered);
1983
+ if (seal !== null) connection.seal = (granted) => sealSession(seal, granted);
1984
+ if (sealLost) {
1985
+ send({ type: "error", code: "seal_not_kept", message: "This browser did not keep the cookie a sealed sign-in is opened with. Sign in again: it will be handed over as a token." });
1774
1986
  }
1775
1987
  live.set(connection, token !== null && token !== "" && principal !== null ? { token, principal } : null);
1776
1988
  connection.onClose(() => live.delete(connection));
@@ -1976,7 +2188,9 @@ var createShellHost = (ctx) => {
1976
2188
  };
1977
2189
  const delta = ctx.delta ?? false;
1978
2190
  const DELTA_CEILING = 0.6;
2191
+ const DELTA_MAX_FRAME = 64 * 1024;
1979
2192
  const shorterAsDelta = (previous, next, canvasId) => {
2193
+ if (previous.length > DELTA_MAX_FRAME || next.length > DELTA_MAX_FRAME) return null;
1980
2194
  try {
1981
2195
  const ops = encodeDelta(previous, next);
1982
2196
  const message = { type: "render-delta", canvas: canvasId, ops, hash: frameHash(next) };
@@ -2034,7 +2248,15 @@ var createShellHost = (ctx) => {
2034
2248
  // ephemeral and dies on detach.
2035
2249
  grant: (token2) => {
2036
2250
  const message = JSON.stringify({ type: "session", token: token2 });
2037
- for (const connection of liveRef?.connections ?? []) connection.send(message);
2251
+ for (const connection of liveRef?.connections ?? []) {
2252
+ if (connection.seal === void 0) connection.send(message);
2253
+ else {
2254
+ void connection.seal(token2).then(
2255
+ (sealed) => connection.send(JSON.stringify({ type: "session", sealed })),
2256
+ (error) => console.error("[moss] a sign-in could not be sealed, and was not handed over:", error)
2257
+ );
2258
+ }
2259
+ }
2038
2260
  },
2039
2261
  // REVOKE: forget the credential, close every terminal SIGNED_OUT,
2040
2262
  // evict the durable shell. Under moss's own credential the rows go
@@ -2269,8 +2491,8 @@ var createShellHost = (ctx) => {
2269
2491
  const settle = async (live, waitMs) => {
2270
2492
  const started = Date.now();
2271
2493
  let timer;
2272
- const deadline = new Promise((resolve) => {
2273
- timer = setTimeout(() => resolve(false), waitMs);
2494
+ const deadline = new Promise((resolve2) => {
2495
+ timer = setTimeout(() => resolve2(false), waitMs);
2274
2496
  });
2275
2497
  const whole = live.seeded.then(() => nova.shellSettled(live.shell, { waitMs: Math.max(0, waitMs - (Date.now() - started)), stopped: () => live.ended }));
2276
2498
  const settled = await Promise.race([whole, deadline]);
@@ -2359,7 +2581,7 @@ var createShellHost = (ctx) => {
2359
2581
  const settled = await settle(cell.live, waitMs);
2360
2582
  return { ...read(cell.live), settled, ...needOf(cell.live, principal) };
2361
2583
  }
2362
- const seed = crypto.randomBytes(9).toString("hex");
2584
+ const seed = crypto$1.randomBytes(9).toString("hex");
2363
2585
  const live = await build(token, principal, false, seed, options?.inputs);
2364
2586
  try {
2365
2587
  const settled = await settle(live, waitMs);
@@ -2630,7 +2852,7 @@ var createIdentityCache = (ctx) => {
2630
2852
  };
2631
2853
 
2632
2854
  // src/server.ts
2633
- var secretsEqual = (a, b) => crypto.timingSafeEqual(crypto.createHash("sha256").update(a).digest(), crypto.createHash("sha256").update(b).digest());
2855
+ var secretsEqual = (a, b) => crypto$1.timingSafeEqual(crypto$1.createHash("sha256").update(a).digest(), crypto$1.createHash("sha256").update(b).digest());
2634
2856
  var guardOperator = (operator, opts) => {
2635
2857
  const gate = opts.gate;
2636
2858
  if (gate !== void 0) operator.use("*", (c, next) => Promise.resolve(gate(c, next)));
@@ -2658,12 +2880,7 @@ var createServer = async (app, runtime) => {
2658
2880
  const session = sessionVerifierOf(runtime);
2659
2881
  const emit = emitterOf(runtime.telemetry);
2660
2882
  const vexOnExecute = emit === void 0 ? void 0 : (rec) => emit(vexRecordToSpan(rec));
2661
- const cacheSequence = (runtime.cache ?? vex.createPostgresCache({ pool: runtime.pool })).sequence;
2662
- await postgres.migrate(
2663
- runtime.pool,
2664
- [MOSS_SEQUENCE, ...runtime.session === "sessions" ? [SESSIONS_SEQUENCE] : [], ...cacheSequence === void 0 ? [] : [cacheSequence]],
2665
- { mode: runtime.migrations ?? "apply" }
2666
- );
2883
+ await postgres.migrate(runtime.pool, tableSequencesOf(runtime), { mode: runtime.migrations ?? "apply" });
2667
2884
  const grammars = await createGrammarUpgrader(app);
2668
2885
  await postgres.upgradeStore(runtime.pool, INTEGRATION_ACTIONS_STORE, grammars);
2669
2886
  const data = await createDataLayer(runtime, app.entries ?? []);
@@ -2740,7 +2957,7 @@ ${variantErrors.map((e) => ` ${e}`).join("\n")}`);
2740
2957
  revalidateMs: runtime.sessionRevalidateMs ?? DEFAULT_REVALIDATE_MS
2741
2958
  }) : void 0;
2742
2959
  const keys = /* @__PURE__ */ new WeakMap();
2743
- const keyOf = (record) => {
2960
+ const keyOf2 = (record) => {
2744
2961
  const hit = keys.get(record);
2745
2962
  if (hit !== void 0) return hit;
2746
2963
  const key = memoKey(record.roles, record.installed);
@@ -2756,7 +2973,7 @@ ${variantErrors.map((e) => ` ${e}`).join("\n")}`);
2756
2973
  const resolveIdentity = async (principal) => {
2757
2974
  if (identities !== void 0 && principal !== null) {
2758
2975
  const record = await identities.get(principal);
2759
- return { roles: record.roles, scope: record.scope, installed: record.installed, key: keyOf(record), record };
2976
+ return { roles: record.roles, scope: record.scope, installed: record.installed, key: keyOf2(record), record };
2760
2977
  }
2761
2978
  return fromSeams(principal);
2762
2979
  };
@@ -3156,7 +3373,7 @@ ${variantErrors.map((e) => ` ${e}`).join("\n")}`);
3156
3373
  if (!frameAdmits(found.frames ?? {}, path, held)) return c.json({ message: "No such frame." }, 404);
3157
3374
  const now = Date.now();
3158
3375
  sweepGrants(now);
3159
- const token = crypto.randomBytes(24).toString("hex");
3376
+ const token = crypto$1.randomBytes(24).toString("hex");
3160
3377
  grants.set(token, { integration: id, principal, path, expires: now + GRANT_TTL_MS });
3161
3378
  return c.json({ src: `/integrations/${id}/frame/${token}`, expiresIn: GRANT_TTL_MS });
3162
3379
  });
@@ -3363,7 +3580,7 @@ ${variantErrors.map((e) => ` ${e}`).join("\n")}`);
3363
3580
  if (host === void 0 || manifest === void 0) return void 0;
3364
3581
  return { name: matched.name, host, inputs: manifest.params === void 0 ? {} : { [manifest.params]: matched.params } };
3365
3582
  };
3366
- const fabricOrigin = crypto.randomBytes(8).toString("hex");
3583
+ const fabricOrigin = crypto$1.randomBytes(8).toString("hex");
3367
3584
  const applyInvalidateIdentity = (principal) => {
3368
3585
  const held = identities?.invalidate(principal) ?? false;
3369
3586
  shells?.reset(principal);
@@ -3427,7 +3644,9 @@ ${nextVariantErrors.map((e) => ` ${e}`).join("\n")}`);
3427
3644
  ...shells !== void 0 ? { shells } : {},
3428
3645
  page: pageAt,
3429
3646
  ...runtime.sessionRevalidateMs !== void 0 ? { revalidateMs: runtime.sessionRevalidateMs } : {},
3430
- ...runtime.telemetry !== void 0 ? { telemetry: runtime.telemetry } : {}
3647
+ ...runtime.telemetry !== void 0 ? { telemetry: runtime.telemetry } : {},
3648
+ ...runtime.origins !== void 0 ? { origins: runtime.origins } : {},
3649
+ ...runtime.session === "sessions" ? { sessionLastsMs: (token) => sessionRemainingMs(runtime.pool, token) } : {}
3431
3650
  });
3432
3651
  return Object.assign(server, {
3433
3652
  socket,
@@ -3559,23 +3778,7 @@ var createTideDriver = (config) => {
3559
3778
  };
3560
3779
  };
3561
3780
  var SNAPSHOT_ELEMENT_ID = "nisc-snapshot";
3562
- var DEFAULT_TOKEN_KEY = "nisc.token";
3563
3781
  var DEFAULT_ROOT = '<div id="root"></div>';
3564
- var tokenFromCookie = (header, tokenKey = DEFAULT_TOKEN_KEY) => {
3565
- if (header === void 0 || header === null) return null;
3566
- const wanted = encodeURIComponent(tokenKey);
3567
- for (const part of header.split(";")) {
3568
- const at = part.indexOf("=");
3569
- if (at < 0 || part.slice(0, at).trim() !== wanted) continue;
3570
- try {
3571
- const value = decodeURIComponent(part.slice(at + 1).trim());
3572
- return value === "" ? null : value;
3573
- } catch {
3574
- return null;
3575
- }
3576
- }
3577
- return null;
3578
- };
3579
3782
  var embedSnapshot = (snapshot, principal, path) => {
3580
3783
  const { frame, trees, seed, live } = snapshot;
3581
3784
  const text = JSON.stringify({ frame, trees, principal: principal !== null, live, ...seed !== void 0 ? { seed } : {}, ...path !== void 0 ? { path } : {} }).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
@@ -3590,7 +3793,8 @@ var renderDocument = async (config) => {
3590
3793
  const undrawn = { html: template, headers: documentHeaders(null), drawn: false, principal: null };
3591
3794
  if (!template.includes(root)) return undrawn;
3592
3795
  try {
3593
- const token = tokenFromCookie(request.cookie, tokenKey);
3796
+ const ports = [/:(\d+)$/.exec(request.host ?? "")?.[1] ?? "", ...config.site !== void 0 && URL.canParse(config.site) ? [new URL(config.site).port] : []];
3797
+ const token = ports.map((port) => sessionTokenOf(request.cookie, { port }, tokenKey)?.token ?? null).find((found) => found !== null) ?? null;
3594
3798
  const principal = token === null ? null : await server.principalOf(token);
3595
3799
  const route = server.page(request.path);
3596
3800
  const host = route?.host ?? server.shells;
@@ -3608,10 +3812,7 @@ var renderDocument = async (config) => {
3608
3812
  return {
3609
3813
  html,
3610
3814
  ...head !== void 0 ? { head } : {},
3611
- headers: {
3612
- ...documentHeaders(principal),
3613
- ...token !== null && principal === null ? { "set-cookie": `${encodeURIComponent(tokenKey)}=; Path=/; Max-Age=0; SameSite=Lax` } : {}
3614
- },
3815
+ headers: documentHeaders(principal),
3615
3816
  drawn: true,
3616
3817
  principal,
3617
3818
  ...route !== void 0 ? { page: route.name } : {},
@@ -3656,6 +3857,7 @@ exports.DEFAULT_IDLE_MS = DEFAULT_IDLE_MS;
3656
3857
  exports.DEFAULT_REVALIDATE_MS = DEFAULT_REVALIDATE_MS;
3657
3858
  exports.GENERATION_DDL = GENERATION_DDL;
3658
3859
  exports.MOSS_SEQUENCE = MOSS_SEQUENCE;
3860
+ exports.PROTOCOL = PROTOCOL;
3659
3861
  exports.SESSIONS_SEQUENCE = SESSIONS_SEQUENCE;
3660
3862
  exports.SNAPSHOT_ELEMENT_ID = SNAPSHOT_ELEMENT_ID;
3661
3863
  exports.TIDE_DDL = TIDE_DDL;
@@ -3694,10 +3896,12 @@ exports.listIntegrations = listIntegrations;
3694
3896
  exports.listPlacements = listPlacements;
3695
3897
  exports.loadIntegrationActions = loadIntegrationActions;
3696
3898
  exports.memoKeyOf = memoKeyOf;
3899
+ exports.migrateTables = migrateTables;
3697
3900
  exports.mintDevToken = mintDevToken;
3698
3901
  exports.mintIntegrationKey = mintIntegrationKey;
3699
3902
  exports.mintSession = mintSession;
3700
3903
  exports.mintWrites = mintWrites;
3904
+ exports.offerToken = offerToken;
3701
3905
  exports.renderDocument = renderDocument;
3702
3906
  exports.resolveCatalog = resolveCatalog;
3703
3907
  exports.resolveCatalogForRoles = resolveCatalogForRoles;
@@ -3710,6 +3914,7 @@ exports.resolveVariantsForRoles = resolveVariantsForRoles;
3710
3914
  exports.revokeAllFor = revokeAllFor;
3711
3915
  exports.revokeSession = revokeSession;
3712
3916
  exports.runIntake = runIntake;
3917
+ exports.sessionCookies = sessionCookies;
3713
3918
  exports.sessionOf = sessionOf;
3714
3919
  exports.sessionVerifierOf = sessionVerifierOf;
3715
3920
  exports.shellNeedOf = shellNeedOf;