@secondlayer/shared 2.1.0 → 3.0.0-beta.1

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/migrations/0057_subscriptions.ts

@@ -0,0 +1,137 @@
+import { type Kysely, sql } from "kysely";
+
+/**
+ * Subgraph event subscriptions — the new core surface after the workflow pivot.
+ *
+ * Three tables:
+ *   - `subscriptions`: user-facing configuration. One row per subscription.
+ *   - `subscription_outbox`: exactly-once emission ledger. Inserted inside the
+ *     same tx as the row write, drained by the emitter worker.
+ *   - `subscription_deliveries`: per-attempt HTTP dispatch log. Truncated
+ *     response bodies + status code for UI + retention.
+ *
+ * Trigger `subscription_outbox_notify` fires `pg_notify('subscriptions:new_outbox', <sub_id>)`
+ * on insert so the emitter can wake without polling.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await sql`
+		CREATE TABLE subscriptions (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			account_id UUID NOT NULL,
+			project_id UUID,
+			name TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			subgraph_name TEXT NOT NULL,
+			table_name TEXT NOT NULL,
+			filter JSONB NOT NULL DEFAULT '{}'::jsonb,
+			format TEXT NOT NULL DEFAULT 'standard-webhooks',
+			runtime TEXT,
+			url TEXT NOT NULL,
+			signing_secret_enc BYTEA NOT NULL,
+			auth_config JSONB NOT NULL DEFAULT '{}'::jsonb,
+			max_retries INT NOT NULL DEFAULT 7,
+			timeout_ms INT NOT NULL DEFAULT 10000,
+			concurrency INT NOT NULL DEFAULT 4,
+			circuit_failures INT NOT NULL DEFAULT 0,
+			circuit_opened_at TIMESTAMPTZ,
+			last_delivery_at TIMESTAMPTZ,
+			last_success_at TIMESTAMPTZ,
+			last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+			UNIQUE (account_id, name)
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX subscriptions_matcher_idx
+			ON subscriptions (subgraph_name, table_name, status)
+			WHERE status = 'active'
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX subscriptions_account_idx ON subscriptions (account_id)
+	`.execute(db);
+
+	await sql`
+		CREATE TABLE subscription_outbox (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			subscription_id UUID NOT NULL REFERENCES subscriptions(id) ON DELETE CASCADE,
+			subgraph_name TEXT NOT NULL,
+			table_name TEXT NOT NULL,
+			block_height BIGINT NOT NULL,
+			tx_id TEXT,
+			row_pk JSONB NOT NULL,
+			event_type TEXT NOT NULL,
+			payload JSONB NOT NULL,
+			dedup_key TEXT NOT NULL,
+			attempt INT NOT NULL DEFAULT 0,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+			status TEXT NOT NULL DEFAULT 'pending',
+			is_replay BOOLEAN NOT NULL DEFAULT FALSE,
+			delivered_at TIMESTAMPTZ,
+			failed_at TIMESTAMPTZ,
+			locked_by TEXT,
+			locked_until TIMESTAMPTZ,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+			UNIQUE (subscription_id, dedup_key)
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX outbox_dispatch_idx
+			ON subscription_outbox (status, next_attempt_at, is_replay)
+			WHERE status = 'pending'
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX outbox_sub_idx
+			ON subscription_outbox (subscription_id, created_at DESC)
+	`.execute(db);
+
+	await sql`
+		CREATE TABLE subscription_deliveries (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			outbox_id UUID NOT NULL REFERENCES subscription_outbox(id) ON DELETE CASCADE,
+			subscription_id UUID NOT NULL,
+			attempt INT NOT NULL,
+			status_code INT,
+			response_headers JSONB,
+			response_body TEXT,
+			error_message TEXT,
+			duration_ms INT,
+			dispatched_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+		)
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX deliveries_sub_idx
+			ON subscription_deliveries (subscription_id, dispatched_at DESC)
+	`.execute(db);
+
+	await sql`
+		CREATE OR REPLACE FUNCTION notify_new_outbox() RETURNS TRIGGER AS $$
+		BEGIN
+			PERFORM pg_notify('subscriptions:new_outbox', NEW.subscription_id::text);
+			RETURN NEW;
+		END;
+		$$ LANGUAGE plpgsql
+	`.execute(db);
+
+	await sql`
+		CREATE TRIGGER subscription_outbox_notify
+			AFTER INSERT ON subscription_outbox
+			FOR EACH ROW
+			EXECUTE FUNCTION notify_new_outbox()
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await sql`DROP TRIGGER IF EXISTS subscription_outbox_notify ON subscription_outbox`.execute(
+		db,
+	);
+	await sql`DROP FUNCTION IF EXISTS notify_new_outbox() CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS subscription_deliveries CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS subscription_outbox CASCADE`.execute(db);
+	await sql`DROP TABLE IF EXISTS subscriptions CASCADE`.execute(db);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@secondlayer/shared",
-	"version": "2.1.0",
+	"version": "3.0.0-beta.1",
 	"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"
@@ -65,14 +61,6 @@
 			"types": "./dist/src/schemas/accounts.d.ts",
 			"import": "./dist/src/schemas/accounts.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"
-		},
 		"./db/queries/tenants": {
 			"types": "./dist/src/db/queries/tenants.d.ts",
 			"import": "./dist/src/db/queries/tenants.js"
@@ -85,6 +73,30 @@
 			"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",