@secondlayer/subgraphs 3.26.4 → 4.0.1

package/README.md

@@ -2,7 +2,7 @@
 
 Typed on-chain indexing for Stacks. Declare event filters + column schema with `defineSubgraph()`; the runtime decodes blocks, matches filters, runs your handlers inside a transactional context, and exposes the result as a Postgres schema you query over REST or SQL.
 
-Subgraphs have a visibility: managed deploys default `visibility: public` — anon-readable at `/v1/subgraphs/<name>/<table>`, in a single global public namespace claimed on publish (409 `PUBLIC_NAME_TAKEN` if the name is taken). BYO-database deploys default private. Override with `--visibility public|private` at deploy, or flip later with `sl subgraphs publish|unpublish <name>`.
+Subgraphs have a visibility: deploys default `visibility: public` — anon-readable at `/v1/subgraphs/<name>/<table>`, in a single global public namespace (409 `PUBLIC_NAME_TAKEN` if the name is taken). Override with `--visibility public|private` at deploy.
 
 Subgraph rows fan out to HTTP subscribers through a post-flush outbox emitter — signed Standard Webhooks POSTs with retries, circuit breaker, and replay.
 
@@ -53,7 +53,7 @@ export default defineSubgraph({
 });
 ```
 
-Deploy via CLI (`sl subgraphs deploy path/to/definition.ts`), SDK (`sl.subgraphs.deploy({...})`), or MCP (`subgraphs_deploy`). The CLI can also scaffold from a deployed contract with `sl subgraphs scaffold <contract> -o subgraphs/name.ts`; scaffold writes or amends `package.json` and runs `bun install` unless `--no-install` is passed. The dashboard is read-only — creation always happens through an API surface.
+Deploy via CLI (`secondlayer subgraphs deploy path/to/definition.ts`), SDK (`sl.subgraphs.deploy({...})`), or MCP (`subgraphs_deploy`). The CLI can also scaffold from a deployed contract with `secondlayer subgraphs scaffold <contract> -o subgraphs/name.ts`; scaffold writes or amends `package.json` and runs `bun install` unless `--no-install` is passed. The dashboard is read-only — creation always happens through an API surface.
 
 ## Exports
 
@@ -91,72 +91,19 @@ Delivery bodies and response previews land in `subscription_deliveries`. Rows wh
 | `SECONDLAYER_EMIT_OUTBOX` | `true` | Set `false` to bypass outbox emission on every block (kill-switch). |
 | `SECONDLAYER_ALLOW_PRIVATE_EGRESS` | `false` | Allow the emitter to deliver to private IP ranges (localhost, 10/8, 172.16/12, 192.168/16, link-local, v6 mapped). Leave off in production. |
 | `SECONDLAYER_SECRETS_KEY` | — | 32-byte hex key for the AES-GCM envelope around subscription signing secrets. OSS mode auto-generates + persists to `.env.local`. |
-| `TENANT_PLAN` | unset | Dedicated hosting plan injected by the provisioner. Unset and paid plans use standard batches. |
-| `SUBGRAPH_REINDEX_BATCH_SIZE` | plan-based | Override the default historical block batch size used by reindex/backfill. |
-| `SUBGRAPH_REINDEX_MIN_BATCH_SIZE` | plan-based | Override the adaptive lower bound for reindex/backfill batches. |
-| `SUBGRAPH_REINDEX_MAX_BATCH_SIZE` | plan-based | Override the adaptive upper bound for reindex/backfill batches. |
-| `DATABASE_MAX_POOLS` | `25` | Max cached connection pools. With BYO subgraphs (one pool per user DB) the least-recently-used pool is evicted past this cap; the source/target pools are never evicted. |
-| `DATABASE_IDLE_TIMEOUT` | `300` | Seconds before idle connections are closed (`0` = never). Keeps a fleet of BYO pools from pinning connections. |
+| `SUBGRAPH_REINDEX_BATCH_SIZE` | adaptive | Override the default historical block batch size used by reindex/backfill. |
+| `SUBGRAPH_REINDEX_MIN_BATCH_SIZE` | adaptive | Override the adaptive lower bound for reindex/backfill batches. |
+| `SUBGRAPH_REINDEX_MAX_BATCH_SIZE` | adaptive | Override the adaptive upper bound for reindex/backfill batches. |
+| `DATABASE_MAX_POOLS` | `25` | Max cached connection pools; the least-recently-used pool is evicted past this cap. The source/target pools are never evicted. |
+| `DATABASE_IDLE_TIMEOUT` | `300` | Seconds before idle connections are closed (`0` = never). |
 
-## Bring your own database (BYO data plane)
-
-There are three tiers, not two:
-
-| Tier | Indexer / decode | Handler exec | Database | Serving API |
-| --- | --- | --- | --- | --- |
-| Managed (default) | ours | ours | ours | ours |
-| **BYO data plane** | ours | ours | **yours** | **yours** |
-| Self-host | yours | yours | yours | yours |
-
-With BYO, the managed pipeline (ingest → decode → match → run your handler) is
-unchanged, but your handler's rows land in **your** Postgres and the serving API
-reads from there. Deploy with a connection string:
-
-```bash
-sl subgraphs deploy subgraphs/my.ts --database-url "postgres://user:pass@your-host:5432/db"
-```
-
-BYO deploys default `visibility: private` (managed deploys default public);
-pass `--visibility public` or `sl subgraphs publish <name>` to open reads.
-
-The connection string is stored encrypted at rest (AES-GCM, keyed by
-`SECONDLAYER_SECRETS_KEY`) and never returned in API responses. The server
-verifies the connection before deploying. Once deployed, query the
-`subgraph_…` schema directly with any ORM/GraphQL/REST — we're no longer in the
-serving path.
-
-**Preview before it touches your DB.** `POST /api/subgraphs` with
-`{"dryRun": true, "databaseUrl": "…"}` returns the exact DDL plus a grant
-script and verifies the connection — without writing anything.
-
-**Constraints (v1):**
-
-- **Idempotent handlers only.** A BYO block write can't share the managed
-  transaction, so a crash replays the block (at-least-once). `ctx.insert` and
-  `ctx.upsert` (with a unique key) are safe — flush is replace-per-height. A
-  deploy with non-idempotent `ctx.update` / `ctx.patchOrInsert` is rejected.
-- **No reindex.** A breaking change (removed table/column, changed type, or a
-  forced reindex) would drop + rebuild the schema in your DB, so the deploy is
-  refused with HTTP `422` — nothing is touched. The refusal carries a migration
-  plan: the SDK throws a typed `ByoBreakingChangeError` (`details.reasons` +
-  `details.plan` with `dropStatement`/`statements`/`grantScript`) and the CLI
-  prints the exact `DROP SCHEMA … CASCADE` + rebuild DDL to run yourself, then
-  re-deploy. A destructive `--force` rebuild on your DB is not yet supported.
-- **Delete leaves your data.** Deleting the subgraph removes our registry row
-  (and the stored connection) and pauses subscriptions, but never drops the
-  schema in your database.
-
-**Recommended:** give Secondlayer a least-privilege role scoped to its own
-schema, and point `--database-url` at a session-mode pooler endpoint
-(PgBouncer/Neon/Supabase) rather than raw Postgres.
-
-### ORM codegen
+## ORM codegen
 
 Once rows land in your DB, generate a typed schema for your ORM:
 
 ```bash
-sl subgraphs codegen subgraphs/my.ts --target prisma  -o prisma/schema.prisma
-sl subgraphs codegen subgraphs/my.ts --target drizzle -o db/schema.ts
+secondlayer subgraphs codegen subgraphs/my.ts --target prisma  -o prisma/schema.prisma
+secondlayer subgraphs codegen subgraphs/my.ts --target drizzle -o db/schema.ts
 ```
 
 Prisma and Drizzle have first-class generators (`generatePrismaSchema` /

package/dist/src/index.d.ts

@@ -474,10 +474,9 @@ declare function canSparseScan(subgraph: SubgraphDefinition): boolean;
 declare function sparseProbeTargets(subgraph: SubgraphDefinition): SparseProbeTarget[];
 interface ReindexOptions {
 	/**
-	* Policy floor on the walk's first block — NOT a caller-supplied range.
-	* Free-tier accounts may not reindex below their registered `start_block`
-	* (see `resolveGenesisPolicy` on the API side); this raises the walk start
-	* and can never lower it. There is deliberately no `toBlock` counterpart:
+	* Floor on the walk's first block — NOT a caller-supplied range. When set
+	* (e.g. an op row carrying a `from_block`), it raises the walk start and
+	* can never lower it. There is deliberately no `toBlock` counterpart:
 	* a reindex always runs to chain tip. See {@link resolveBlockRange}.
 	*/
 	startBlockFloor?: number;
@@ -1103,7 +1102,6 @@ declare function generateIndexSchema(target: IndexCodegenTarget, opts?: IndexCod
 declare const INDEX_CODEGEN_TABLES: readonly string[];
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
 import { Database as Database3 } from "@secondlayer/shared/db";
-import { ByoBreakingChangeDetails } from "@secondlayer/shared/errors";
 import { Kysely as Kysely3 } from "kysely";
 type AnyDb = Kysely3<Database3>;
 interface TableDiff {
@@ -1163,36 +1161,16 @@ interface DeployDiff {
 	/** uniqueKeys added in place via ALTER TABLE … ADD CONSTRAINT. */
 	addedUniqueKeys?: Record<string, string[][]>;
 }
-interface ByoMigrationPlan {
-	schemaName: string;
-	dropStatement: string;
-	statements: string[];
-	grantScript: string;
-}
-/**
-* Thrown when a BYO subgraph deploy is refused for a breaking schema change.
-* Plain `Error` with a literal `code` (not `SecondLayerError`) so the API
-* middleware matches it by code across bundle boundaries — bunup duplicates
-* classes per package, breaking cross-bundle `instanceof`. The refusal stands;
-* `details` carries the reviewable DROP + rebuild the user must run manually.
-*/
-declare class ByoBreakingChangeError extends Error {
-	readonly code: "BYO_BREAKING_CHANGE";
-	readonly details: ByoBreakingChangeDetails;
-	constructor(reasons: string[], diff: DeployDiff, plan: ByoMigrationPlan);
-}
 interface DeployPlan {
 	schemaName: string;
-	/** `DROP SCHEMA … CASCADE` a destructive rebuild would run first (shown, never auto-run on BYO). */
+	/** `DROP SCHEMA … CASCADE` a destructive rebuild would run first. */
 	dropStatement: string;
-	/** DDL Secondlayer will run against your database. */
+	/** DDL the deploy will run. */
 	statements: string[];
-	/** Least-privilege grant script to run once, before deploying. */
-	grantScript: string;
 }
 /**
-* Render the DDL + grant script a BYO deploy would run, without executing.
-* Powers `--dry-run`: the user reviews exactly what touches their DB first.
+* Render the DDL a deploy would run, without executing.
+* Powers `--dry-run`: the user reviews exactly what a deploy does first.
 */
 declare function renderDeployPlan(def: SubgraphDefinition, schemaName?: string): DeployPlan;
 /**
@@ -1210,14 +1188,6 @@ declare function deploySchema(db: AnyDb, def: SubgraphDefinition, handlerPath: s
 	version?: string
 	handlerCode?: string
 	sourceCode?: string
-	/**
-	* BYO data plane: when set, schema DDL (CREATE/ALTER/index) runs against
-	* the user-owned DB while the subgraphs registry row stays on `db`
-	* (managed). Defaults to `db` — managed deploys are unchanged.
-	*/
-	dataDb?: AnyDb
-	/** Encrypted user-DB connection string to persist on the registry row. */
-	databaseUrlEnc?: Buffer | null
 }): Promise<{
 	action: "created" | "unchanged" | "handler_updated" | "updated" | "reindexed"
 	subgraphId: string
@@ -1226,4 +1196,4 @@ declare function deploySchema(db: AnyDb, def: SubgraphDefinition, handlerPath: s
 	/** Non-fatal caveats the caller should surface (e.g. handler grafts at tip). */
 	warnings?: string[]
 }>;
-export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, readContractAt, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, filterFieldsByType, diffSchema, deploySchema, defineSubgraph, defineSchema, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferContext, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, FactoryScope, EventForFilter, ErasedChainReadClient, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ChainReadOptions, ChainReadMethods, ChainReadError, ChainReadClient, ChainReadCacheMode, ByoMigrationPlan, ByoBreakingChangeError, AnyEvent, AggregateSpec, AggregateResult };
+export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, readContractAt, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, filterFieldsByType, diffSchema, deploySchema, defineSubgraph, defineSchema, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferContext, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, FactoryScope, EventForFilter, ErasedChainReadClient, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ChainReadOptions, ChainReadMethods, ChainReadError, ChainReadClient, ChainReadCacheMode, AnyEvent, AggregateSpec, AggregateResult };

package/dist/src/index.js

@@ -538,16 +538,14 @@ class SubgraphContext {
   pgSchemaName;
   subgraphSchema;
   ops = [];
-  byo;
   journal;
   _client;
-  constructor(db, pgSchemaName2, subgraphSchema, block, tx, byo = false, journal = false) {
+  constructor(db, pgSchemaName2, subgraphSchema, block, tx, journal = false) {
     this.db = db;
     this.pgSchemaName = pgSchemaName2;
     this.subgraphSchema = subgraphSchema;
     this.block = block;
     this._tx = tx;
-    this.byo = byo;
     this.journal = journal;
   }
   get client() {
@@ -916,15 +914,6 @@ class SubgraphContext {
   }
   buildStatements(ops) {
     const statements = [];
-    if (this.byo) {
-      const insertTables = new Set;
-      for (const op of ops)
-        if (op.kind === "insert")
-          insertTables.add(op.table);
-      for (const table of insertTables) {
-        statements.push(`DELETE FROM "${this.pgSchemaName}"."${table}" WHERE "_block_height" = ${this.block.height}`);
-      }
-    }
     let currentBatch = null;
     let currentBatchKey = "";
     let incBatch = null;
@@ -1877,16 +1866,13 @@ function matchSources(sources, transactions, events, traitContracts = new Map, f
 }
 
 // src/runtime/block-processor.ts
-import { secretsKeyAvailable } from "@secondlayer/shared/crypto/secrets";
 import { getTargetDb } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
 import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
 import {
-  isByoSubgraph,
   recordLiveError,
   recordLiveProgress,
   recordSubgraphProcessed,
-  resolveSubgraphDb,
   rewindLiveProgress,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
@@ -2815,26 +2801,14 @@ async function refreshMatcher(db) {
 
 // src/runtime/block-processor.ts
 var routeCache = new Map;
-
-class ByoKeyUnavailableError extends Error {
-  constructor(subgraphName) {
-    super(`subgraph ${subgraphName} is BYO (database_url_enc set) but this process has no SECONDLAYER_SECRETS_KEY — the subgraph processor deliberately does not hold it (f072). Route BYO subgraphs to a process that does, or unset BYO.`);
-    this.name = "ByoKeyUnavailableError";
-  }
-}
 async function resolveRoute(subgraphName, targetDb) {
   const cached = routeCache.get(subgraphName);
   if (cached)
     return cached;
   const row = await targetDb.selectFrom("subgraphs").selectAll().where("name", "=", subgraphName).executeTakeFirst();
-  const byo = row ? isByoSubgraph(row) : false;
-  if (row && byo && !secretsKeyAvailable()) {
-    throw new ByoKeyUnavailableError(subgraphName);
-  }
   const route = {
     schemaName: row?.schema_name ?? pgSchemaName(subgraphName),
-    dataDb: row && byo ? resolveSubgraphDb(row) : targetDb,
-    byo,
+    dataDb: targetDb,
     sandboxWorkers: row?.sandbox_workers === true,
     handlerCode: row?.handler_code ?? null,
     version: row?.version ?? ""
@@ -3042,7 +3016,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       await rewindLiveProgress(tx, subgraphName, blockHeight);
     } else {
       const advanced = await recordLiveProgress(tx, subgraphName, blockHeight);
-      if (!advanced && flushedWrites && !route.byo) {
+      if (!advanced && flushedWrites) {
         throw new LiveCursorRaceLostError(subgraphName, blockHeight);
       }
     }
@@ -3051,122 +3025,79 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       await recordSubgraphProcessed(tx, subgraphName, rr.processed, rr.errors, lastError);
     }
   };
-  if (route.byo) {
-    if (statusMode(opts)) {
-      const row = await targetDb.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
-      if (row && Number(row.last_processed_block) >= blockHeight) {
-        result.skipped = true;
-        return result;
-      }
-    } else if (opCursorMode(opts)) {
-      const om = opCursorMode(opts);
-      const row = await targetDb.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", om.operationId).executeTakeFirst();
-      if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
-        result.skipped = true;
-        return result;
+  try {
+    await targetDb.transaction().execute(async (tx) => {
+      const opMode = opCursorMode(opts);
+      const sm = statusMode(opts);
+      const rewind = isReorgRewind(opts);
+      if (sm) {
+        const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
+        if (row && Number(row.last_processed_block) >= blockHeight) {
+          result.skipped = true;
+          return;
+        }
+      } else if (opMode) {
+        const row = await tx.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", opMode.operationId).executeTakeFirst();
+        if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
+          result.skipped = true;
+          return;
+        }
+      } else if (!rewind) {
+        const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
+        if (row && Number(row.last_processed_block) >= blockHeight) {
+          result.skipped = true;
+          return;
+        }
       }
-    }
-    let runResult = { processed: 0, errors: 0 };
-    let manifest;
-    await route.dataDb.transaction().execute(async (tx) => {
-      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, true, journalEnabled(opts));
+      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, journalEnabled(opts));
       const handlerStart = performance.now();
-      runResult = await runHandlers(subgraph, matched, ctx);
+      const runResult = sandboxEnabled({
+        sandbox_workers: route.sandboxWorkers
+      }) ? await runHandlersSandboxed({
+        subgraphName,
+        version: route.version,
+        handlerCode: route.handlerCode,
+        hostCtx: ctx,
+        block: blockMeta,
+        matched
+      }) : await runHandlers(subgraph, matched, ctx);
       handlerMs = performance.now() - handlerStart;
+      result.processed = runResult.processed;
+      result.errors = runResult.errors;
+      let flushedWrites = false;
       if (ctx.pendingOps > 0) {
         const flushStart = performance.now();
-        manifest = await ctx.flush();
+        const manifest = await ctx.flush();
+        flushedWrites = manifest.count > 0;
+        if (manifest.count > 0) {
+          await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+        }
         flushMs = performance.now() - flushStart;
       }
-    });
-    result.processed = runResult.processed;
-    result.errors = runResult.errors;
-    await persistFactoryDiscoveries(schemaName, route.dataDb, blockHeight, discovered);
-    await targetDb.transaction().execute(async (tx) => {
-      if (manifest && manifest.count > 0) {
-        await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
-      }
-      const byoSm = statusMode(opts);
-      const byoOm = opCursorMode(opts);
-      if (byoSm && manifest && manifest.count > 0) {
-        await updateSubgraphStatus(tx, subgraphName, byoSm.status, blockHeight);
-      } else if (byoOm && manifest && manifest.count > 0) {
-        await advanceOperationCursor(tx, byoOm.operationId, blockHeight);
+      if (sm && flushedWrites) {
+        await updateSubgraphStatus(tx, subgraphName, sm.status, blockHeight);
+      } else if (opMode && flushedWrites) {
+        const advanced = await advanceOperationCursor(tx, opMode.operationId, blockHeight);
+        if (!advanced) {
+          throw new CursorRaceLostError(opMode.operationId, blockHeight);
+        }
       }
-      await applyProgress(tx, runResult, manifest ? manifest.count > 0 : false);
+      await applyProgress(tx, runResult, flushedWrites);
     });
-  } else {
-    try {
-      await targetDb.transaction().execute(async (tx) => {
-        const opMode = opCursorMode(opts);
-        const sm = statusMode(opts);
-        const rewind = isReorgRewind(opts);
-        if (sm) {
-          const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
-          if (row && Number(row.last_processed_block) >= blockHeight) {
-            result.skipped = true;
-            return;
-          }
-        } else if (opMode) {
-          const row = await tx.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", opMode.operationId).executeTakeFirst();
-          if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
-            result.skipped = true;
-            return;
-          }
-        } else if (!rewind) {
-          const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
-          if (row && Number(row.last_processed_block) >= blockHeight) {
-            result.skipped = true;
-            return;
-          }
-        }
-        const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
-        const handlerStart = performance.now();
-        const runResult = sandboxEnabled({
-          sandbox_workers: route.sandboxWorkers
-        }) ? await runHandlersSandboxed({
-          subgraphName,
-          version: route.version,
-          handlerCode: route.handlerCode,
-          hostCtx: ctx,
-          block: blockMeta,
-          matched
-        }) : await runHandlers(subgraph, matched, ctx);
-        handlerMs = performance.now() - handlerStart;
-        result.processed = runResult.processed;
-        result.errors = runResult.errors;
-        let flushedWrites = false;
-        if (ctx.pendingOps > 0) {
-          const flushStart = performance.now();
-          const manifest = await ctx.flush();
-          flushedWrites = manifest.count > 0;
-          if (manifest.count > 0) {
-            await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
-          }
-          flushMs = performance.now() - flushStart;
-        }
-        if (sm && flushedWrites) {
-          await updateSubgraphStatus(tx, subgraphName, sm.status, blockHeight);
-        } else if (opMode && flushedWrites) {
-          const advanced = await advanceOperationCursor(tx, opMode.operationId, blockHeight);
-          if (!advanced) {
-            throw new CursorRaceLostError(opMode.operationId, blockHeight);
-          }
-        }
-        await applyProgress(tx, runResult, flushedWrites);
+  } catch (err) {
+    if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
+      logger7.warn("cursor race lost — block already covered", {
+        subgraph: subgraphName,
+        blockHeight,
+        error: err.message
       });
-    } catch (err) {
-      if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
-        logger7.warn("cursor race lost — block already covered", {
-          subgraph: subgraphName,
-          blockHeight,
-          error: err.message
-        });
-        result.skipped = true;
-        return result;
-      }
-      throw err;
+      result.skipped = true;
+      return result;
     }
+    throw err;
+  }
+  if (!result.skipped) {
+    await persistFactoryDiscoveries(schemaName, route.dataDb, blockHeight, discovered);
   }
   const totalMs = performance.now() - blockStart;
   if (!result.skipped) {
@@ -5055,16 +4986,6 @@ function bumpPatch(version) {
   const patch = Number.parseInt(parts[2] ?? "0", 10);
   return `${parts[0]}.${parts[1]}.${Number.isNaN(patch) ? 1 : patch + 1}`;
 }
-
-class ByoBreakingChangeError extends Error {
-  code = "BYO_BREAKING_CHANGE";
-  details;
-  constructor(reasons, diff, plan) {
-    super("Breaking schema change on a BYO subgraph would drop data in your " + "database. Review the plan and run the DROP + rebuild DDL manually.");
-    this.name = "ByoBreakingChangeError";
-    this.details = { reasons, diff, plan };
-  }
-}
 function toDeployDiff(diff, reasons) {
   return {
     addedTables: diff?.addedTables ?? [],
@@ -5078,31 +4999,13 @@ function renderDeployPlan(def, schemaName) {
   const { statements } = generateSubgraphSQL(def, schemaName);
   const schema = schemaName ?? pgSchemaName(def.name);
   const dropStatement = `DROP SCHEMA IF EXISTS "${schema}" CASCADE;`;
-  const grantScript = [
-    "-- Run once on YOUR database as an owner/superuser, replacing <role>",
-    "-- with the role whose credentials you give Secondlayer.",
-    "-- Secondlayer then creates and owns only this one schema:",
-    "GRANT CREATE ON DATABASE current_database() TO <role>;",
-    `-- (after first deploy <role> owns "${schema}"; no further grants needed)`
-  ].join(`
-`);
-  return { schemaName: schema, dropStatement, statements, grantScript };
+  return { schemaName: schema, dropStatement, statements };
 }
 async function deploySchema(db, def, handlerPath, opts) {
   validateSubgraphDefinition(def);
   const { statements, hash } = generateSubgraphSQL(def, opts?.schemaName);
   const { getSubgraph: getSubgraph2, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
-  const ddlDb = opts?.dataDb ?? db;
-  const byo = opts?.dataDb != null;
-  const refuseDestructiveOnByo = (reasons, diff) => {
-    const plan = renderDeployPlan(def, opts?.schemaName);
-    throw new ByoBreakingChangeError(reasons, toDeployDiff(diff, reasons), {
-      schemaName: plan.schemaName,
-      dropStatement: plan.dropStatement,
-      statements: plan.statements,
-      grantScript: plan.grantScript
-    });
-  };
+  const ddlDb = db;
   const existing = await getSubgraph2(db, def.name, opts?.accountId);
   const schemaName = opts?.schemaName ?? pgSchemaName(def.name);
   const newVersion = opts?.version ?? (existing ? bumpPatch(existing.version) : "1.0.0");
@@ -5124,8 +5027,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     handlerCode: opts?.handlerCode,
     sourceCode: opts?.sourceCode,
     schemaName,
-    startBlock: def.startBlock,
-    databaseUrlEnc: opts?.databaseUrlEnc ?? null
+    startBlock: def.startBlock
   };
   if (existing) {
     const schemaExists = await sql5`
@@ -5160,8 +5062,6 @@ async function deploySchema(db, def, handlerPath, opts) {
       };
     }
     if (existing.schema_hash === hash && opts?.forceReindex) {
-      if (byo)
-        refuseDestructiveOnByo(["force reindex"], null);
       await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
       for (const stmt of statements) {
         await sql5.raw(stmt).execute(ddlDb);
@@ -5173,9 +5073,6 @@ async function deploySchema(db, def, handlerPath, opts) {
       const diff = diffSchema(existing.definition.schema, def.schema);
       const { breaking, reasons } = hasBreakingChanges(diff);
       if (breaking || opts?.forceReindex) {
-        if (byo) {
-          refuseDestructiveOnByo(reasons.length > 0 ? reasons : ["force reindex"], diff);
-        }
         await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
         for (const stmt of statements) {
           await sql5.raw(stmt).execute(ddlDb);
@@ -5357,9 +5254,8 @@ export {
   camelizeDataKey,
   backfillSubgraph,
   INDEX_CODEGEN_TABLES,
-  ChainReadError,
-  ByoBreakingChangeError
+  ChainReadError
 };
 
-//# debugId=720FEFA20DA031E864756E2164756E21
+//# debugId=544EEADDD1FD235264756E2164756E21
 //# sourceMappingURL=index.js.map