@secondlayer/shared 2.0.0 → 3.0.0-alpha.0

package/migrations/0048_tenant_compute_addons.ts

@@ -0,0 +1,49 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Compute add-ons on top of a plan's base spec.
+ *
+ * The two-axis model (plan × compute) needs somewhere to record "Pro +
+ * 4 GB RAM bundle" without mutating the plan. Each row is one add-on;
+ * SUM() over active rows for a tenant gives the delta to apply on top
+ * of `plans.ts` base compute.
+ *
+ * Columns kept as *_delta so "zero add-ons" is the identity (no
+ * nullables in the sum path). Effective compute = plan base +
+ * SUM(active deltas).
+ *
+ * `effective_until` nullable — open-ended add-on (active until cancelled).
+ * Ranges allow future-dated add-ons + mid-cycle cancels cleanly.
+ *
+ * `stripe_subscription_item_id` nullable — present once Sprint C.2/C.3
+ * wire Stripe. For Sprint C.1 the table exists but nothing writes it.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		CREATE TABLE tenant_compute_addons (
+			id                          uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			tenant_id                   uuid NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
+			memory_mb_delta             integer NOT NULL DEFAULT 0,
+			cpu_delta                   numeric(4,2) NOT NULL DEFAULT 0,
+			storage_mb_delta            integer NOT NULL DEFAULT 0,
+			effective_from              timestamptz NOT NULL DEFAULT now(),
+			effective_until             timestamptz,
+			stripe_subscription_item_id text,
+			created_at                  timestamptz NOT NULL DEFAULT now()
+		)
+	`.execute(db);
+
+	// Partial index limited to open-ended add-ons (the common case) —
+	// `now()` isn't immutable so it can't appear in a WHERE clause here.
+	// Closed-end add-ons still get served from a seq scan + date filter,
+	// which is cheap at our row counts.
+	await sql`
+		CREATE INDEX tenant_compute_addons_tenant_idx
+			ON tenant_compute_addons (tenant_id)
+			WHERE effective_until IS NULL
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TABLE IF EXISTS tenant_compute_addons`.execute(db);
+}

package/migrations/0049_accounts_stripe_customer_id.ts

@@ -0,0 +1,30 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Link accounts to Stripe customers.
+ *
+ * Nullable because we create the Stripe customer lazily — only when an
+ * account upgrades past Hobby. Hobby users never show up in Stripe, which
+ * keeps the dashboard clean and avoids Stripe-side overhead per free user.
+ *
+ * Unique index (not constraint) so the column stays nullable but still
+ * enforces one-to-one when set.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		ALTER TABLE accounts
+			ADD COLUMN IF NOT EXISTS stripe_customer_id text
+	`.execute(db);
+	await sql`
+		CREATE UNIQUE INDEX IF NOT EXISTS accounts_stripe_customer_idx
+			ON accounts (stripe_customer_id)
+			WHERE stripe_customer_id IS NOT NULL
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP INDEX IF EXISTS accounts_stripe_customer_idx`.execute(db);
+	await sql`
+		ALTER TABLE accounts DROP COLUMN IF EXISTS stripe_customer_id
+	`.execute(db);
+}

package/migrations/0050_account_spend_caps.ts

@@ -0,0 +1,45 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Per-account spending caps + threshold alert state.
+ *
+ * This is the anti-Supabase-#1-complaint differentiator: soft caps with
+ * 80% threshold email alerts, per-line sub-caps, and a clear "frozen"
+ * state the user can unfreeze by raising the cap (instead of Supabase's
+ * binary cap that blocks certain line items but not compute, producing
+ * surprise bills).
+ *
+ * One row per account (account_id is PK). Null caps mean "no cap" for
+ * that line. `frozen_at` is set by the metering worker when a cap is
+ * hit; cleared on the next billing cycle's `invoice.paid` webhook. While
+ * frozen, meter events stop accumulating for that account.
+ *
+ * `alert_threshold_pct` default 80 — the Supabase request that's been
+ * open since 2023.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		CREATE TABLE account_spend_caps (
+			account_id              uuid PRIMARY KEY REFERENCES accounts(id) ON DELETE CASCADE,
+			monthly_cap_cents       integer,
+			compute_cap_cents       integer,
+			storage_cap_cents       integer,
+			ai_cap_cents            integer,
+			alert_threshold_pct     integer NOT NULL DEFAULT 80,
+			alert_sent_at           timestamptz,
+			frozen_at               timestamptz,
+			updated_at              timestamptz NOT NULL DEFAULT now()
+		)
+	`.execute(db);
+
+	// Fast lookup for the metering crons: "is this account currently frozen?"
+	await sql`
+		CREATE INDEX account_spend_caps_frozen_idx
+			ON account_spend_caps (account_id)
+			WHERE frozen_at IS NOT NULL
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TABLE IF EXISTS account_spend_caps`.execute(db);
+}

package/migrations/0051_workflow_ai_usage_daily.ts

@@ -0,0 +1,40 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Per-tenant-per-day AI eval counter.
+ *
+ * The workflow-runner bumps this on every `step.ai` / `step.generateText`
+ * / `step.generateObject` call. A daily per-tier cap (see `pricing.ts`
+ * helpers) gates new AI calls — when the cap is hit, `step.ai` throws
+ * and workflows degrade to their condition-only path.
+ *
+ * The runner package is currently dead (tables dropped in migration
+ * 0038); when it returns, these rows are the source of truth for cap
+ * enforcement + AI overage metering to Stripe.
+ *
+ * PK on (tenant_id, day) — one row per tenant per UTC day. `evals` is
+ * the call count, `cost_usd_cents` is our internal cost estimate for
+ * sanity-checking Stripe meter events later.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		CREATE TABLE workflow_ai_usage_daily (
+			tenant_id       uuid NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
+			day             date NOT NULL,
+			evals           integer NOT NULL DEFAULT 0,
+			cost_usd_cents  integer NOT NULL DEFAULT 0,
+			first_at        timestamptz NOT NULL DEFAULT now(),
+			last_at         timestamptz NOT NULL DEFAULT now(),
+			PRIMARY KEY (tenant_id, day)
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX workflow_ai_usage_daily_lookup_idx
+			ON workflow_ai_usage_daily (tenant_id, day DESC)
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TABLE IF EXISTS workflow_ai_usage_daily`.execute(db);
+}

package/migrations/0052_sentries.ts

@@ -0,0 +1,61 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Protocol Sentry v1 — packaged monitoring product.
+ *
+ * `sentries` holds per-account enabled sentries. Worker cron ticks every
+ * 60s, loads active rows, runs per-kind detect SQL on the shared indexer
+ * DB, AI-triages matches, delivers to `delivery_webhook` (Slack-shape).
+ *
+ * `sentry_alerts` holds one row per delivered alert. UNIQUE on
+ * (sentry_id, idempotency_key) dedupes across ticks — key is
+ * sha256(txId:eventIndex) for the large-outflow kind.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		CREATE TABLE sentries (
+			id                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			account_id        uuid NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
+			kind              text NOT NULL,
+			name              text NOT NULL,
+			config            jsonb NOT NULL,
+			active            boolean NOT NULL DEFAULT true,
+			last_check_at     timestamptz,
+			delivery_webhook  text NOT NULL,
+			created_at        timestamptz NOT NULL DEFAULT now(),
+			updated_at        timestamptz NOT NULL DEFAULT now()
+		)
+	`.execute(db);
+
+	await sql`CREATE INDEX sentries_account_idx ON sentries (account_id)`.execute(
+		db,
+	);
+	await sql`
+		CREATE INDEX sentries_tick_idx
+			ON sentries (active, last_check_at NULLS FIRST)
+			WHERE active = true
+	`.execute(db);
+
+	await sql`
+		CREATE TABLE sentry_alerts (
+			id                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			sentry_id         uuid NOT NULL REFERENCES sentries(id) ON DELETE CASCADE,
+			idempotency_key   text NOT NULL,
+			fired_at          timestamptz NOT NULL DEFAULT now(),
+			payload           jsonb NOT NULL,
+			delivery_status   text NOT NULL DEFAULT 'pending',
+			delivery_error    text,
+			UNIQUE (sentry_id, idempotency_key)
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX sentry_alerts_sentry_fired_idx
+			ON sentry_alerts (sentry_id, fired_at DESC)
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TABLE IF EXISTS sentry_alerts`.execute(db);
+	await sql`DROP TABLE IF EXISTS sentries`.execute(db);
+}

package/migrations/0053_workflow_runtime.ts

@@ -0,0 +1,88 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Workflow runtime tables (v3).
+ *
+ * Minimal revival of the runner's execution substrate after migration
+ * 0038 dropped the v2 tables. No `workflow_definitions` — v3 is a
+ * zero-sugar TS SDK, definitions live in compiled code + a process-
+ * local registry, not the DB. No schedules / cursors / signer secrets
+ * / budgets — consumers own their own scheduling; broadcast/budget
+ * features land in later migrations when a consumer needs them.
+ *
+ *   workflow_runs    — one row per enqueued invocation
+ *   workflow_steps   — memoized `step.*` outputs, keyed by
+ *                      `sha256(stepId + canonicalJSON(inputs))`
+ *   workflow_queue   — SKIP LOCKED dispatch table; one or more rows
+ *                      per run (one per scheduling — sleeps re-enqueue)
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		CREATE TABLE workflow_runs (
+			id               uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			workflow_name    text NOT NULL,
+			input            jsonb NOT NULL DEFAULT '{}'::jsonb,
+			status           text NOT NULL DEFAULT 'queued',
+			output           jsonb,
+			error            text,
+			started_at       timestamptz,
+			completed_at     timestamptz,
+			created_at       timestamptz NOT NULL DEFAULT now()
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX workflow_runs_name_status_idx
+			ON workflow_runs (workflow_name, status, created_at DESC)
+	`.execute(db);
+
+	await sql`
+		CREATE TABLE workflow_steps (
+			id               uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			run_id           uuid NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+			step_id          text NOT NULL,
+			memo_key         text NOT NULL,
+			status           text NOT NULL DEFAULT 'pending',
+			output           jsonb,
+			error            text,
+			attempts         integer NOT NULL DEFAULT 0,
+			started_at       timestamptz,
+			completed_at     timestamptz,
+			created_at       timestamptz NOT NULL DEFAULT now(),
+			UNIQUE (run_id, memo_key)
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX workflow_steps_run_idx
+			ON workflow_steps (run_id, created_at ASC)
+	`.execute(db);
+
+	await sql`
+		CREATE TABLE workflow_queue (
+			id               uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+			run_id           uuid NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+			status           text NOT NULL DEFAULT 'pending',
+			attempts         integer NOT NULL DEFAULT 0,
+			max_attempts     integer NOT NULL DEFAULT 3,
+			scheduled_for    timestamptz NOT NULL DEFAULT now(),
+			locked_at        timestamptz,
+			locked_by        text,
+			error            text,
+			completed_at     timestamptz,
+			created_at       timestamptz NOT NULL DEFAULT now()
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX workflow_queue_dispatch_idx
+			ON workflow_queue (status, scheduled_for)
+			WHERE status = 'pending'
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TABLE IF EXISTS workflow_queue CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS workflow_steps CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS workflow_runs CASCADE`.execute(db);
+}

package/migrations/0054_accounts_plan_hobby.ts

@@ -0,0 +1,32 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Normalize the legacy `free` plan string to `hobby`.
+ *
+ * Migration 0004 originally set `accounts.plan` default to `"free"` when
+ * the tier vocabulary was free/pro/builder. The pricing model later
+ * settled on `hobby/launch/grow/scale/enterprise`. Every lookup table
+ * (pricing.ts allowances, TIER_META, webhook handlers) is keyed on
+ * `hobby` — but existing signups still carry `plan='free'`, breaking
+ * the usage + billing pages' tier mapping.
+ *
+ * This migration:
+ *   1. Backfills existing rows: `free` → `hobby`
+ *   2. Flips the column default so new signups default to `hobby`
+ *
+ * No paid accounts are affected (no existing `plan` value maps to a
+ * current tier except `hobby` and whatever a webhook has written).
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`UPDATE accounts SET plan = 'hobby' WHERE plan = 'free'`.execute(db);
+	await sql`ALTER TABLE accounts ALTER COLUMN plan SET DEFAULT 'hobby'`.execute(
+		db,
+	);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`ALTER TABLE accounts ALTER COLUMN plan SET DEFAULT 'free'`.execute(
+		db,
+	);
+	await sql`UPDATE accounts SET plan = 'free' WHERE plan = 'hobby'`.execute(db);
+}

package/migrations/0055_ai_usage_account_scope.ts

@@ -0,0 +1,108 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Re-scope workflow AI usage to the account level.
+ *
+ * Sentries have no tenant (they're account-level), so the original
+ * `workflow_ai_usage_daily` schema keyed on `(tenant_id, day)` can't
+ * attribute a sentry's AI calls to an account. This migration:
+ *
+ *   1. Adds `account_id` (NOT NULL) and makes `tenant_id` nullable on
+ *      `workflow_ai_usage_daily`.
+ *   2. Drops the old PK, replaces with a UNIQUE index using
+ *      `NULLS NOT DISTINCT` so two NULL-tenant rows for the same
+ *      account+day conflict correctly (requires PG 15+, matches prod).
+ *   3. Adds `account_id` + `tenant_id` nullable columns to
+ *      `workflow_runs` so the processor can set AsyncLocalStorage
+ *      context before invoking the handler — AI middleware reads this
+ *      context to attribute usage back to the caller.
+ *
+ * Backfill for existing rows joins through `tenants.account_id`.
+ * On prod the table has 0 rows (AI middleware was a no-op previously),
+ * so backfill is a formality.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// ── workflow_ai_usage_daily ──────────────────────────────────────
+	await sql`
+		ALTER TABLE workflow_ai_usage_daily
+			ADD COLUMN account_id uuid REFERENCES accounts(id) ON DELETE CASCADE
+	`.execute(db);
+
+	await sql`
+		UPDATE workflow_ai_usage_daily u
+		SET account_id = t.account_id
+		FROM tenants t
+		WHERE u.tenant_id = t.id AND u.account_id IS NULL
+	`.execute(db);
+
+	// Drop any rows we couldn't backfill (orphans — tenant already deleted).
+	await sql`DELETE FROM workflow_ai_usage_daily WHERE account_id IS NULL`.execute(
+		db,
+	);
+
+	// Drop the old PK first — it includes tenant_id, which blocks the
+	// subsequent DROP NOT NULL.
+	await sql`
+		ALTER TABLE workflow_ai_usage_daily
+			DROP CONSTRAINT workflow_ai_usage_daily_pkey
+	`.execute(db);
+
+	await sql`
+		ALTER TABLE workflow_ai_usage_daily
+			ALTER COLUMN account_id SET NOT NULL,
+			ALTER COLUMN tenant_id DROP NOT NULL
+	`.execute(db);
+
+	await sql`
+		CREATE UNIQUE INDEX workflow_ai_usage_daily_account_tenant_day_key
+			ON workflow_ai_usage_daily (account_id, tenant_id, day)
+			NULLS NOT DISTINCT
+	`.execute(db);
+
+	await sql`DROP INDEX IF EXISTS workflow_ai_usage_daily_lookup_idx`.execute(
+		db,
+	);
+	await sql`
+		CREATE INDEX workflow_ai_usage_daily_account_day_idx
+			ON workflow_ai_usage_daily (account_id, day DESC)
+	`.execute(db);
+
+	// ── workflow_runs ────────────────────────────────────────────────
+	await sql`
+		ALTER TABLE workflow_runs
+			ADD COLUMN account_id uuid REFERENCES accounts(id) ON DELETE SET NULL,
+			ADD COLUMN tenant_id  uuid REFERENCES tenants(id)  ON DELETE SET NULL
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX workflow_runs_account_idx
+			ON workflow_runs (account_id, created_at DESC)
+			WHERE account_id IS NOT NULL
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP INDEX IF EXISTS workflow_runs_account_idx`.execute(db);
+	await sql`
+		ALTER TABLE workflow_runs
+			DROP COLUMN IF EXISTS account_id,
+			DROP COLUMN IF EXISTS tenant_id
+	`.execute(db);
+
+	await sql`DROP INDEX IF EXISTS workflow_ai_usage_daily_account_day_idx`.execute(
+		db,
+	);
+	await sql`DROP INDEX IF EXISTS workflow_ai_usage_daily_account_tenant_day_key`.execute(
+		db,
+	);
+	// Best-effort: rows without tenant_id fill would violate NOT NULL on
+	// revert. Assume down is dev-only.
+	await sql`DELETE FROM workflow_ai_usage_daily WHERE tenant_id IS NULL`.execute(
+		db,
+	);
+	await sql`
+		ALTER TABLE workflow_ai_usage_daily
+			ALTER COLUMN tenant_id SET NOT NULL,
+			DROP COLUMN account_id
+	`.execute(db);
+}

package/migrations/0056_drop_workflow_sentry_residuals.ts

@@ -0,0 +1,23 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Drop all residual workflow + sentry tables after the product pivot.
+ * Workflows/runner/sentries packages are gone; these tables have no writers.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TABLE IF EXISTS sentry_alerts CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS sentries CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS workflow_queue CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS workflow_steps CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS workflow_runs CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS workflow_ai_usage_daily CASCADE`.execute(db);
+
+	await sql`DROP TRIGGER IF EXISTS tx_confirmed_trigger ON transactions`.execute(
+		db,
+	);
+	await sql`DROP FUNCTION IF EXISTS tx_confirmed_notify() CASCADE`.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {
+	throw new Error("0056 is a one-way demolition; restore from backup");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@secondlayer/shared",
-	"version": "2.0.0",
+	"version": "3.0.0-alpha.0",
 	"type": "module",
 	"main": "./dist/src/index.js",
 	"types": "./dist/src/index.d.ts",
@@ -41,10 +41,6 @@
 			"types": "./dist/src/db/schema.d.ts",
 			"import": "./dist/src/db/schema.js"
 		},
-		"./lib/plans": {
-			"types": "./dist/src/lib/plans.d.ts",
-			"import": "./dist/src/lib/plans.js"
-		},
 		"./queue/listener": {
 			"types": "./dist/src/queue/listener.d.ts",
 			"import": "./dist/src/queue/listener.js"
@@ -61,30 +57,46 @@
 			"types": "./dist/src/schemas/subgraphs.d.ts",
 			"import": "./dist/src/schemas/subgraphs.js"
 		},
-		"./schemas/marketplace": {
-			"types": "./dist/src/schemas/marketplace.d.ts",
-			"import": "./dist/src/schemas/marketplace.js"
-		},
-		"./schemas/workflows": {
-			"types": "./dist/src/schemas/workflows.d.ts",
-			"import": "./dist/src/schemas/workflows.js"
-		},
-		"./db/queries/workflows": {
-			"types": "./dist/src/db/queries/workflows.d.ts",
-			"import": "./dist/src/db/queries/workflows.js"
+		"./schemas/accounts": {
+			"types": "./dist/src/schemas/accounts.d.ts",
+			"import": "./dist/src/schemas/accounts.js"
 		},
 		"./db/queries/tenants": {
 			"types": "./dist/src/db/queries/tenants.d.ts",
 			"import": "./dist/src/db/queries/tenants.js"
 		},
-		"./db/queries/marketplace": {
-			"types": "./dist/src/db/queries/marketplace.d.ts",
-			"import": "./dist/src/db/queries/marketplace.js"
-		},
 		"./db/queries/projects": {
 			"types": "./dist/src/db/queries/projects.d.ts",
 			"import": "./dist/src/db/queries/projects.js"
 		},
+		"./db/queries/provisioning-audit": {
+			"types": "./dist/src/db/queries/provisioning-audit.d.ts",
+			"import": "./dist/src/db/queries/provisioning-audit.js"
+		},
+		"./db/queries/tenant-compute-addons": {
+			"types": "./dist/src/db/queries/tenant-compute-addons.d.ts",
+			"import": "./dist/src/db/queries/tenant-compute-addons.js"
+		},
+		"./db/queries/account-spend-caps": {
+			"types": "./dist/src/db/queries/account-spend-caps.d.ts",
+			"import": "./dist/src/db/queries/account-spend-caps.js"
+		},
+		"./db/queries/sentries": {
+			"types": "./dist/src/db/queries/sentries.d.ts",
+			"import": "./dist/src/db/queries/sentries.js"
+		},
+		"./db/queries/account-usage": {
+			"types": "./dist/src/db/queries/account-usage.d.ts",
+			"import": "./dist/src/db/queries/account-usage.js"
+		},
+		"./db/queries/workflow-runs": {
+			"types": "./dist/src/db/queries/workflow-runs.d.ts",
+			"import": "./dist/src/db/queries/workflow-runs.js"
+		},
+		"./schemas/sentries": {
+			"types": "./dist/src/schemas/sentries.d.ts",
+			"import": "./dist/src/schemas/sentries.js"
+		},
 		"./types": {
 			"types": "./dist/src/types.d.ts",
 			"import": "./dist/src/types.js"
@@ -164,7 +176,7 @@
 		"prepublishOnly": "bun run build"
 	},
 	"dependencies": {
-		"@secondlayer/stacks": "^0.3.0",
+		"@secondlayer/stacks": "^1.0.0-alpha.0",
 		"kysely": "0.28.15",
 		"kysely-postgres-js": "3.0.0",
 		"postgres": "^3.4.6",