@secondlayer/shared 11.19.3 → 11.21.0

package/migrations/0153_vm_events_height_ordinal_pk.ts

@@ -0,0 +1,80 @@
+import { type Kysely, sql } from "kysely";
+import { onChainPlane } from "../src/db/migration-role.ts";
+
+/**
+ * `vm_events` primary key = `(block_height, ordinal)`, the row's logical id.
+ *
+ * The random `id UUID` key put every insert on a random page of a 5 GB index,
+ * and that random read was most of the indexer's write time on a full sync.
+ * The logical key is append-ordered, so inserts touch the right edge only.
+ *
+ * Catalog-only on any size table: `vm_events_logical_id_uniq` already holds
+ * the key, so it is promoted (`ADD PRIMARY KEY USING INDEX`, no rebuild, no
+ * NOT NULL scan: both columns are already NOT NULL) and `DROP COLUMN` only
+ * marks the column dropped. The ACCESS EXCLUSIVE lock is held for the catalog
+ * swap, not a table pass. Only a DB missing the unique index builds it inline.
+ *
+ * Indexes dropped:
+ *   - `vm_events_block_height_idx`: a prefix of the new key.
+ *   - `vm_events_type_height_idx`: a prefix of
+ *     `vm_events_type_height_ordinal_idx`, which the Index and Streams vm
+ *     readers seek (`type`, height range, `ORDER BY block_height, ordinal`).
+ * Kept: `vm_events_tx_id_idx`. No reader filters vm_events by tx_id, but
+ * `vm_events_tx_id_fkey` cascades from `transactions`; without it every
+ * transaction delete (reorg replace, repair) seq-scans vm_events.
+ *
+ * `vm_events_archive.id` stays TEXT; archives now write
+ * `block_height:ordinal` there (see `archiveOrphanedHeight`).
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await onChainPlane(async () => {
+		await sql`SET LOCAL lock_timeout = '30s'`.execute(db);
+		await sql`SET LOCAL statement_timeout = 0`.execute(db);
+
+		const hasIdColumn = await sql<{ one: number }>`
+			SELECT 1 AS one FROM information_schema.columns
+			 WHERE table_schema = current_schema()
+			   AND table_name = 'vm_events' AND column_name = 'id'
+		`.execute(db);
+		if (hasIdColumn.rows.length === 0) return;
+
+		await sql`
+			CREATE UNIQUE INDEX IF NOT EXISTS vm_events_logical_id_uniq
+			ON vm_events (block_height, ordinal)
+		`.execute(db);
+		await sql`ALTER TABLE vm_events DROP CONSTRAINT vm_events_pkey`.execute(db);
+		await sql`
+			ALTER TABLE vm_events
+				ADD CONSTRAINT vm_events_pkey PRIMARY KEY
+				USING INDEX vm_events_logical_id_uniq
+		`.execute(db);
+		await sql`ALTER TABLE vm_events DROP COLUMN id`.execute(db);
+		await sql`DROP INDEX IF EXISTS vm_events_block_height_idx`.execute(db);
+		await sql`DROP INDEX IF EXISTS vm_events_type_height_idx`.execute(db);
+	});
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await onChainPlane(async () => {
+		await sql`SET LOCAL lock_timeout = '30s'`.execute(db);
+		await sql`SET LOCAL statement_timeout = 0`.execute(db);
+		await sql`
+			CREATE INDEX IF NOT EXISTS vm_events_type_height_idx
+			ON vm_events (type, block_height)
+		`.execute(db);
+		await sql`
+			CREATE INDEX IF NOT EXISTS vm_events_block_height_idx
+			ON vm_events (block_height)
+		`.execute(db);
+		await sql`
+			ALTER TABLE vm_events
+				ADD COLUMN IF NOT EXISTS id UUID NOT NULL DEFAULT gen_random_uuid()
+		`.execute(db);
+		await sql`ALTER TABLE vm_events DROP CONSTRAINT vm_events_pkey`.execute(db);
+		await sql`ALTER TABLE vm_events ADD PRIMARY KEY (id)`.execute(db);
+		await sql`
+			CREATE UNIQUE INDEX IF NOT EXISTS vm_events_logical_id_uniq
+			ON vm_events (block_height, ordinal)
+		`.execute(db);
+	});
+}

package/migrations/0154_state_writes.ts

@@ -0,0 +1,62 @@
+import { type Kysely, sql } from "kysely";
+import { onChainPlane } from "../src/db/migration-role.ts";
+
+/**
+ * Opt-in node `state_writes` (`events_keys` `"state_writes"`): the exact MARF
+ * writes a block committed, captured at the storage layer. Replaces the
+ * evaluator-hooked `vm_events` var_set/map_* rows for verification: every
+ * changed MARF leaf in a block must be named here.
+ *
+ * Key = `(block_height, ordinal)`, the node's per-block write order, so inserts
+ * append at the right edge (same shape as `vm_events` after 0153). No other
+ * index: nothing reads this table yet.
+ *
+ * `tx_index` is stored as delivered, not resolved to a `tx_id` FK. It is null
+ * for block-level writes, and a `transactions` FK would cascade this table off
+ * every transaction sweep (child-range repair, re-mine moves) the way
+ * `vm_events.tx_id` does. Rows are height-scoped only: they follow `blocks` via
+ * ON DELETE CASCADE, like every vm row sweep relies on (0133).
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await onChainPlane(async () => {
+		await sql`SET LOCAL lock_timeout = '30s'`.execute(db);
+
+		await sql`
+			CREATE TABLE IF NOT EXISTS state_writes (
+				block_height BIGINT NOT NULL
+					REFERENCES blocks (height) ON DELETE CASCADE,
+				ordinal INTEGER NOT NULL,
+				tx_index INTEGER NULL,
+				key TEXT NOT NULL,
+				value_hex TEXT NOT NULL,
+				CONSTRAINT state_writes_pkey PRIMARY KEY (block_height, ordinal)
+			)
+		`.execute(db);
+
+		await sql`
+			CREATE TABLE IF NOT EXISTS state_writes_archive (
+				archive_id BIGSERIAL PRIMARY KEY,
+				id TEXT NOT NULL,
+				block_height BIGINT NOT NULL,
+				ordinal INTEGER NOT NULL,
+				tx_index INTEGER NULL,
+				key TEXT NOT NULL,
+				value_hex TEXT NOT NULL,
+				orphaned_block_hash TEXT,
+				archived_at TIMESTAMPTZ NOT NULL DEFAULT now()
+			)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX IF NOT EXISTS state_writes_archive_height_idx
+			ON state_writes_archive (block_height)
+		`.execute(db);
+	});
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await onChainPlane(async () => {
+		await sql`DROP TABLE IF EXISTS state_writes_archive`.execute(db);
+		await sql`DROP TABLE IF EXISTS state_writes`.execute(db);
+	});
+}

package/migrations/0155_api_failed_requests.ts

@@ -0,0 +1,37 @@
+import { type Kysely, sql } from "kysely";
+import { onControlPlane } from "../src/db/migration-role.ts";
+
+/**
+ * 24h, account-scoped record of failed hosted API requests (method, path,
+ * status, code, short message, redacted query). Written fire-and-forget by
+ * the error-envelope middleware and read back as server-side evidence when
+ * a caller reports a problem by `request_id`. Purged hourly by the worker.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await onControlPlane(async () => {
+		await sql`
+			CREATE TABLE api_failed_requests (
+				request_id text PRIMARY KEY,
+				account_id uuid NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
+				method     text NOT NULL,
+				path       text NOT NULL,
+				status     integer NOT NULL,
+				code       text NOT NULL,
+				message    text NOT NULL DEFAULT '',
+				query      jsonb NOT NULL DEFAULT '{}'::jsonb,
+				origin     text,
+				created_at timestamptz NOT NULL DEFAULT now()
+			)
+		`.execute(db);
+		await sql`
+			CREATE INDEX api_failed_requests_created_at_idx
+				ON api_failed_requests (created_at)
+		`.execute(db);
+	});
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await onControlPlane(async () => {
+		await sql`DROP TABLE IF EXISTS api_failed_requests`.execute(db);
+	});
+}

package/migrations/0156_feedback_tickets.ts

@@ -0,0 +1,47 @@
+import { type Kysely, sql } from "kysely";
+import { onControlPlane } from "../src/db/migration-role.ts";
+
+/**
+ * Hosted problem reports filed by agents at `POST /v1/feedback`. `attempted`
+ * is copied from `api_failed_requests` by the server, never taken from the
+ * caller. `status` starts `new`; the classify worker moves it to
+ * `classified` and fills `route` / `classification`. One idempotency key per
+ * account de-duplicates retries (NULL keys are always distinct).
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await onControlPlane(async () => {
+		await sql`SET lock_timeout = '30s'`.execute(db);
+
+		await sql`
+			CREATE TABLE feedback_tickets (
+				id              uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+				account_id      uuid NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
+				idempotency_key text,
+				request_id      text,
+				intent          text NOT NULL,
+				expected        jsonb,
+				kind_hint       text,
+				evidence        jsonb,
+				attempted       jsonb,
+				origin          text NOT NULL,
+				status          text NOT NULL DEFAULT 'new' CHECK (status IN ('new', 'classified')),
+				route           text,
+				classification  jsonb,
+				classified_at   timestamptz,
+				created_at      timestamptz NOT NULL DEFAULT now(),
+				UNIQUE (account_id, idempotency_key)
+			)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX feedback_tickets_new_idx
+				ON feedback_tickets (created_at) WHERE status = 'new'
+		`.execute(db);
+	});
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await onControlPlane(async () => {
+		await sql`DROP TABLE IF EXISTS feedback_tickets`.execute(db);
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@secondlayer/shared",
-	"version": "11.19.3",
+	"version": "11.21.0",
 	"description": "Internal building blocks shared across Secondlayer packages.",
 	"license": "MIT",
 	"repository": {
@@ -97,6 +97,10 @@
 			"types": "./dist/src/mode.d.ts",
 			"import": "./dist/src/mode.js"
 		},
+		"./error-envelope": {
+			"types": "./dist/src/error-envelope.d.ts",
+			"import": "./dist/src/error-envelope.js"
+		},
 		"./index-internal-auth": {
 			"types": "./dist/src/index-internal-auth.d.ts",
 			"import": "./dist/src/index-internal-auth.js"
@@ -224,6 +228,10 @@
 		"./email": {
 			"types": "./dist/src/email/index.d.ts",
 			"import": "./dist/src/email/index.js"
+		},
+		"./classify": {
+			"types": "./dist/src/classify/index.d.ts",
+			"import": "./dist/src/classify/index.js"
 		}
 	},
 	"files": ["dist", "migrations"],
@@ -243,6 +251,14 @@
 		"postgres": "^3.4.6",
 		"zod": "^4.3.6"
 	},
+	"peerDependencies": {
+		"ai": "7.0.133"
+	},
+	"peerDependenciesMeta": {
+		"ai": {
+			"optional": true
+		}
+	},
 	"devDependencies": {
 		"@types/bun": "latest",
 		"typescript": "^5"