tradeblocks-mcp 3.3.1 → 3.5.0

package/dist/{chunk-4HZLVUOZ.js → chunk-5HBZ3TZM.js}

@@ -1,20 +1,23 @@
 import {
   REPORTING_TRADE_COLUMN_ALIASES,
   convertTatRowToReportingTrade,
-  isTatFormat
-} from "./chunk-2I3S2ZLT.js";
+  describeReadParquetColumns,
+  isTatFormat,
+  quoteParquetCanonicalProjection,
+  readParquetGlobSql
+} from "./chunk-GD3STARM.js";
 
 // src/sync/index.ts
 import { existsSync as existsSync2 } from "fs";
-import * as fs9 from "fs/promises";
-import * as path12 from "path";
+import * as fs11 from "fs/promises";
+import * as path15 from "path";
 
 // src/db/connection.ts
 import { DuckDBInstance } from "@duckdb/node-api";
 import { execFile } from "child_process";
-import * as fs4 from "fs/promises";
+import * as fs6 from "fs/promises";
 import * as os from "os";
-import * as path8 from "path";
+import * as path11 from "path";
 import { promisify } from "util";
 
 // src/db/schemas.ts
@@ -117,109 +120,1867 @@ async function ensureReportingDataTable(conn) {
     await conn.run(`ALTER TABLE trades.reporting_data ADD COLUMN ticker VARCHAR`);
   }
 }
-
-// src/db/market-schemas.ts
-async function ensureMutableMarketTables(conn) {
-  await conn.run(`
-    CREATE TABLE IF NOT EXISTS market._sync_metadata (
-      source VARCHAR NOT NULL,
-      ticker VARCHAR NOT NULL,
-      target_table VARCHAR NOT NULL,
-
-      content_hash VARCHAR,
-      max_date VARCHAR,
-      wilder_state JSON,
-      synced_at TIMESTAMP NOT NULL,
-
-      PRIMARY KEY (source, ticker, target_table)
-    )
-  `);
-}
-async function ensureMarketDataTables(conn) {
-  for (const name of ["daily", "date_context", "intraday", "data_coverage"]) {
-    try {
-      await conn.run(`DROP VIEW  IF EXISTS market.${name}`);
-    } catch {
-    }
-    try {
-      await conn.run(`DROP TABLE IF EXISTS market.${name}`);
-    } catch {
-    }
+
+// src/db/market-schemas.ts
+async function ensureMutableMarketTables(conn) {
+  await conn.run(`
+    CREATE TABLE IF NOT EXISTS market._sync_metadata (
+      source VARCHAR NOT NULL,
+      ticker VARCHAR NOT NULL,
+      target_table VARCHAR NOT NULL,
+
+      content_hash VARCHAR,
+      max_date VARCHAR,
+      wilder_state JSON,
+      synced_at TIMESTAMP NOT NULL,
+
+      PRIMARY KEY (source, ticker, target_table)
+    )
+  `);
+}
+async function ensureMarketDataTables(conn) {
+  for (const name of ["daily", "date_context", "intraday", "data_coverage"]) {
+    try {
+      await conn.run(`DROP VIEW  IF EXISTS market.${name}`);
+    } catch {
+    }
+    try {
+      await conn.run(`DROP TABLE IF EXISTS market.${name}`);
+    } catch {
+    }
+  }
+  await conn.run(`
+    CREATE TABLE IF NOT EXISTS market.spot (
+      ticker VARCHAR NOT NULL,
+      date   VARCHAR NOT NULL,
+      time   VARCHAR NOT NULL,
+      open   DOUBLE,
+      high   DOUBLE,
+      low    DOUBLE,
+      close  DOUBLE,
+      bid    DOUBLE,
+      ask    DOUBLE,
+      PRIMARY KEY (ticker, date, time)
+    )
+  `);
+  await conn.run(`
+    CREATE TABLE IF NOT EXISTS market.enriched (
+      ticker                  VARCHAR NOT NULL,
+      date                    VARCHAR NOT NULL,
+      Prior_Close             DOUBLE,
+      Gap_Pct                 DOUBLE,
+      ATR_Pct                 DOUBLE,
+      RSI_14                  DOUBLE,
+      Price_vs_EMA21_Pct      DOUBLE,
+      Price_vs_SMA50_Pct      DOUBLE,
+      Realized_Vol_5D         DOUBLE,
+      Realized_Vol_20D        DOUBLE,
+      Return_5D               DOUBLE,
+      Return_20D              DOUBLE,
+      Intraday_Range_Pct      DOUBLE,
+      Intraday_Return_Pct     DOUBLE,
+      Close_Position_In_Range DOUBLE,
+      Gap_Filled              INTEGER,
+      Consecutive_Days        INTEGER,
+      Prev_Return_Pct         DOUBLE,
+      Prior_Range_vs_ATR      DOUBLE,
+      High_Time               DOUBLE,
+      Low_Time                DOUBLE,
+      High_Before_Low         INTEGER,
+      Reversal_Type           INTEGER,
+      Opening_Drive_Strength  DOUBLE,
+      Intraday_Realized_Vol   DOUBLE,
+      Day_of_Week             INTEGER,
+      Month                   INTEGER,
+      Is_Opex                 INTEGER,
+      ivr                     DOUBLE,
+      ivp                     DOUBLE,
+      PRIMARY KEY (ticker, date)
+    )
+  `);
+  await conn.run(`
+    CREATE TABLE IF NOT EXISTS market.enriched_context (
+      date                 VARCHAR NOT NULL,
+      Vol_Regime           INTEGER,
+      Term_Structure_State INTEGER,
+      Trend_Direction      VARCHAR,
+      VIX_Spike_Pct        DOUBLE,
+      VIX_Gap_Pct          DOUBLE,
+      PRIMARY KEY (date)
+    )
+  `);
+}
+
+// src/db/parquet-writer.ts
+import { createHash as createHash3 } from "crypto";
+import { createReadStream } from "fs";
+import * as fs3 from "fs/promises";
+import * as path6 from "path";
+
+// src/market/provenance/partition-commit-store.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { constants, readFileSync } from "fs";
+import * as fs2 from "fs/promises";
+import { hostname } from "os";
+import * as path3 from "path";
+
+// src/market/provenance/canonical-json.ts
+import { createHash } from "crypto";
+var CANONICAL_JSON_VERSION = 1;
+var SHA256_ADDRESS_RE = /^sha256:([0-9a-f]{64})$/;
+function compareCodePoints(left, right) {
+  const leftPoints = Array.from(left, (char) => char.codePointAt(0));
+  const rightPoints = Array.from(right, (char) => char.codePointAt(0));
+  const length = Math.min(leftPoints.length, rightPoints.length);
+  for (let i = 0; i < length; i++) {
+    if (leftPoints[i] !== rightPoints[i]) return leftPoints[i] - rightPoints[i];
+  }
+  return leftPoints.length - rightPoints.length;
+}
+function encode(value, seen) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value.normalize("NFC"));
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (!Number.isSafeInteger(value)) {
+        throw new TypeError("Canonical JSON v1 supports only safe integers");
+      }
+      return JSON.stringify(value);
+    case "undefined":
+    case "function":
+    case "symbol":
+    case "bigint":
+      throw new TypeError(`Canonical JSON does not support ${typeof value}`);
+    case "object":
+      break;
+  }
+  const object = value;
+  if (seen.has(object)) throw new TypeError("Canonical JSON does not support cyclic values");
+  seen.add(object);
+  try {
+    if (Array.isArray(value)) {
+      const elements = [];
+      for (let i = 0; i < value.length; i++) {
+        if (!(i in value)) throw new TypeError("Canonical JSON does not support sparse arrays");
+        elements.push(encode(value[i], seen));
+      }
+      return `[${elements.join(",")}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("Canonical JSON accepts only plain objects and arrays");
+    }
+    const normalizedKeys = /* @__PURE__ */ new Map();
+    for (const sourceKey of Object.keys(value)) {
+      const normalizedKey = sourceKey.normalize("NFC");
+      const collision = normalizedKeys.get(normalizedKey);
+      if (collision !== void 0 && collision !== sourceKey) {
+        throw new TypeError(
+          `Canonical JSON key collision after NFC normalization: ${JSON.stringify(collision)} and ${JSON.stringify(sourceKey)}`
+        );
+      }
+      normalizedKeys.set(normalizedKey, sourceKey);
+    }
+    const entries = [...normalizedKeys.entries()].sort(([left], [right]) => compareCodePoints(left, right)).map(
+      ([normalizedKey, sourceKey]) => `${JSON.stringify(normalizedKey)}:${encode(value[sourceKey], seen)}`
+    );
+    return `{${entries.join(",")}}`;
+  } finally {
+    seen.delete(object);
+  }
+}
+function canonicalJson(value) {
+  return encode(value, /* @__PURE__ */ new WeakSet());
+}
+function canonicalJsonBytes(value) {
+  return Buffer.from(canonicalJson(value), "utf8");
+}
+function addressCanonicalJson(value) {
+  return addressBytes(canonicalJsonBytes(value));
+}
+function addressBytes(bytes) {
+  const digest = createHash("sha256").update(bytes).digest("hex");
+  return `sha256:${digest}`;
+}
+function parseCanonicalJsonAddress(address) {
+  return parseSha256Address(address);
+}
+function parseSha256Address(address) {
+  const match = SHA256_ADDRESS_RE.exec(address);
+  if (!match) throw new TypeError(`Invalid SHA-256 address: ${JSON.stringify(address)}`);
+  return match[1];
+}
+
+// src/market/provenance/content-object-store.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { randomUUID } from "crypto";
+var ContentObjectCollisionError = class extends Error {
+  address;
+  objectPath;
+  constructor(address, objectPath) {
+    super(`Content object collision or corruption at ${address} (${objectPath})`);
+    this.name = "ContentObjectCollisionError";
+    this.address = address;
+    this.objectPath = objectPath;
+  }
+};
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+var ContentObjectStore = class {
+  rootDir;
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  objectPath(address) {
+    const digest = parseCanonicalJsonAddress(address);
+    return path.join(this.rootDir, "objects", "sha256", digest.slice(0, 2), `${digest}.json`);
+  }
+  async syncDirectory(directory) {
+    const handle = await fs.open(directory, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  async ensureDurableDirectory(directory) {
+    const parent = path.dirname(directory);
+    if (parent !== directory) await this.ensureDurableDirectory(parent);
+    try {
+      const handle = await fs.open(directory, "r");
+      try {
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      if (parent !== directory) await this.syncDirectory(parent);
+      return;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (parent === directory)
+      throw new Error(`Cannot create content-object directory ${directory}`);
+    let created = false;
+    try {
+      await fs.mkdir(directory);
+      created = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    if (created) {
+      await this.syncDirectory(directory);
+      await this.syncDirectory(parent);
+    }
+  }
+  async syncExistingObject(objectPath) {
+    const handle = await fs.open(objectPath, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await this.syncDirectory(path.dirname(objectPath));
+  }
+  async put(value) {
+    const bytes = canonicalJsonBytes(value);
+    const address = addressBytes(bytes);
+    const materialized = deepFreeze(JSON.parse(bytes.toString("utf8")));
+    const objectPath = this.objectPath(address);
+    const objectDir = path.dirname(objectPath);
+    await this.ensureDurableDirectory(objectDir);
+    const tempPath = path.join(objectDir, `.${path.basename(objectPath)}.tmp-${randomUUID()}`);
+    let handle;
+    try {
+      handle = await fs.open(tempPath, "wx", 292);
+      await handle.writeFile(bytes);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      await fs.link(tempPath, objectPath);
+      await this.syncDirectory(objectDir);
+      await fs.unlink(tempPath);
+      await this.syncDirectory(objectDir);
+      return {
+        address,
+        value: materialized,
+        path: objectPath,
+        bytes: bytes.byteLength,
+        created: true
+      };
+    } catch (error) {
+      await handle?.close();
+      handle = void 0;
+      await fs.unlink(tempPath).catch(() => void 0);
+      if (error.code !== "EEXIST") throw error;
+      const existing = await fs.readFile(objectPath);
+      if (!existing.equals(bytes)) throw new ContentObjectCollisionError(address, objectPath);
+      await this.syncExistingObject(objectPath);
+      return {
+        address,
+        value: materialized,
+        path: objectPath,
+        bytes: bytes.byteLength,
+        created: false
+      };
+    } finally {
+      await handle?.close();
+    }
+  }
+  async get(address) {
+    const objectPath = this.objectPath(address);
+    const bytes = await fs.readFile(objectPath);
+    const digestAddress = addressBytes(bytes);
+    if (digestAddress !== address) throw new ContentObjectCollisionError(address, objectPath);
+    const value = JSON.parse(bytes.toString("utf8"));
+    if (!canonicalJsonBytes(value).equals(bytes)) {
+      throw new ContentObjectCollisionError(address, objectPath);
+    }
+    return deepFreeze(value);
+  }
+};
+
+// src/market/provenance/dataset-registry.ts
+import * as path2 from "path";
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function deepFreezeDatasetRegistry(registry) {
+  for (const definition of Object.values(registry)) {
+    Object.freeze(definition.partitionKeys);
+    Object.freeze(definition.provenance);
+    Object.freeze(definition);
+  }
+  return Object.freeze(registry);
+}
+var MARKET_DATASETS = deepFreezeDatasetRegistry({
+  spot: {
+    subdir: "spot",
+    partitionKeys: ["ticker", "date"],
+    filename: "data.parquet",
+    schemaRevision: 1,
+    provenance: { kind: "bounded-session", sessionKey: "date" }
+  },
+  enriched: {
+    subdir: "enriched",
+    partitionKeys: ["ticker", "date"],
+    filename: "data.parquet",
+    schemaRevision: 1,
+    provenance: { kind: "bounded-session", sessionKey: "date" }
+  },
+  enriched_context: {
+    subdir: "enriched/context",
+    partitionKeys: ["date"],
+    filename: "data.parquet",
+    schemaRevision: 1,
+    provenance: { kind: "bounded-session", sessionKey: "date" }
+  },
+  option_chain: {
+    subdir: "option_chain",
+    partitionKeys: ["underlying", "date"],
+    filename: "data.parquet",
+    schemaRevision: 1,
+    provenance: { kind: "bounded-session", sessionKey: "date" }
+  },
+  option_quote_minutes: {
+    subdir: "option_quote_minutes",
+    partitionKeys: ["underlying", "date"],
+    filename: "data.parquet",
+    schemaRevision: 1,
+    provenance: { kind: "bounded-session", sessionKey: "date" }
+  },
+  option_oi_daily: {
+    subdir: "option_oi_daily",
+    partitionKeys: ["underlying", "date"],
+    filename: "data.parquet",
+    schemaRevision: 1,
+    provenance: { kind: "bounded-session", sessionKey: "date" }
+  }
+});
+function isRealMarketSessionDate(value) {
+  if (!ISO_DATE_RE.test(value)) return false;
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+}
+function marketDatasetDefinition(dataset) {
+  return Object.hasOwn(MARKET_DATASETS, dataset) ? MARKET_DATASETS[dataset] : void 0;
+}
+function canonicalPartitionDataset(dataset) {
+  const definition = marketDatasetDefinition(dataset);
+  return definition?.provenance.kind === "bounded-session" ? definition : void 0;
+}
+function validatePartitionIdentity(identity) {
+  const definition = canonicalPartitionDataset(identity.dataset);
+  if (!definition) {
+    throw new TypeError(`Unregistered provenance dataset: ${JSON.stringify(identity.dataset)}`);
+  }
+  const expectedKeys = [...definition.partitionKeys].sort();
+  const observedKeys = Object.keys(identity.partition).sort();
+  if (observedKeys.length !== expectedKeys.length || observedKeys.some((key, index) => key !== expectedKeys[index])) {
+    throw new TypeError(
+      `Invalid provenance partition keys: ${JSON.stringify({ dataset: identity.dataset, observedKeys, expectedKeys })}`
+    );
+  }
+  for (const [key, value] of Object.entries(identity.partition)) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || !/^[A-Za-z0-9._-]+$/.test(value)) {
+      throw new TypeError(`Invalid provenance partition: ${JSON.stringify({ key, value })}`);
+    }
+  }
+  const session = identity.partition[definition.provenance.sessionKey];
+  if (!isRealMarketSessionDate(session)) {
+    throw new TypeError(`Invalid provenance partition date: ${JSON.stringify(session)}`);
+  }
+}
+function canonicalPartitionRelativePath(identity) {
+  validatePartitionIdentity(identity);
+  const definition = canonicalPartitionDataset(identity.dataset);
+  return path2.posix.join(
+    definition.subdir,
+    ...definition.partitionKeys.map((key) => `${key}=${identity.partition[key]}`),
+    definition.filename
+  );
+}
+
+// src/market/provenance/partition-commit-store.ts
+var PARTITION_COMMIT_RECEIPT_KIND = "tradeblocks.market-data.partition-commit";
+var PARTITION_COMMIT_RECEIPT_VERSION = 1;
+var PARTITION_COMMIT_EVENT_KIND = "tradeblocks.market-data.partition-commit-event";
+var PARTITION_COMMIT_EVENT_VERSION = 1;
+var PARTITION_HEAD_KIND = "tradeblocks.market-data.partition-head";
+var PARTITION_HEAD_VERSION = 1;
+var INTERNAL_HISTORICAL_PARTITION_ADOPTION = /* @__PURE__ */ Symbol(
+  "tradeblocks.internal.historical-partition-adoption"
+);
+var partitionCommitTestFaults = /* @__PURE__ */ new WeakMap();
+function setPartitionCommitTestFault(store, fault) {
+  if (fault) partitionCommitTestFaults.set(store, fault);
+  else partitionCommitTestFaults.delete(store);
+}
+function attachPartitionLockCleanupError(primary, cleanup) {
+  if (primary instanceof Error) {
+    try {
+      Object.defineProperty(primary, "cleanupError", {
+        value: cleanup,
+        enumerable: false,
+        configurable: true
+      });
+      return primary;
+    } catch {
+    }
+  }
+  return new AggregateError(
+    [primary, cleanup],
+    "Partition operation failed and its lock claim could not be released",
+    { cause: primary }
+  );
+}
+var PartitionFileIntegrityError = class extends Error {
+  filePath;
+  constructor(filePath, reason, cause) {
+    super(`Invalid partition file (${reason}): ${filePath}`, {
+      ...cause === void 0 ? {} : { cause }
+    });
+    this.name = "PartitionFileIntegrityError";
+    this.filePath = filePath;
+  }
+};
+var TOKEN_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var CURRENT_HOSTNAME = hostname();
+var CURRENT_BOOT_ID = (() => {
+  try {
+    const value = readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+    return value.length > 0 ? value : "unavailable";
+  } catch {
+    return "unavailable";
+  }
+})();
+function validateIdentity(identity) {
+  validatePartitionIdentity(identity);
+}
+function canonicalRelativePath(identity) {
+  return canonicalPartitionRelativePath(identity);
+}
+function validateRelativePath(relativePath) {
+  if (relativePath.length === 0 || relativePath.includes("\\") || path3.posix.isAbsolute(relativePath) || relativePath.split("/").some((part) => part === ".." || part === "." || part === "")) {
+    throw new TypeError(`Invalid provenance relative path: ${JSON.stringify(relativePath)}`);
+  }
+}
+function validateRegistryPath(identity, relativePath) {
+  validateRelativePath(relativePath);
+  const expected = canonicalRelativePath(identity);
+  if (relativePath !== expected) {
+    throw new TypeError(
+      `Provenance path does not match the registered partition: ${JSON.stringify({ expected, observed: relativePath })}`
+    );
+  }
+}
+function validateFingerprint(file) {
+  parseSha256Address(file.address);
+  if (!Number.isSafeInteger(file.bytes) || file.bytes < 0) {
+    throw new TypeError(`Invalid provenance byte count: ${file.bytes}`);
+  }
+  if (!Number.isSafeInteger(file.rows) || file.rows < 0) {
+    throw new TypeError(`Invalid provenance row count: ${file.rows}`);
+  }
+}
+function validateCoverage(coverage, rows) {
+  if (coverage.kind === "empty") {
+    if (rows !== 0) throw new TypeError("Non-empty partition cannot have empty logical coverage");
+    return;
+  }
+  if (!isRealMarketSessionDate(coverage.from) || !isRealMarketSessionDate(coverage.through)) {
+    throw new TypeError(`Invalid logical date coverage: ${JSON.stringify(coverage)}`);
+  }
+  if (coverage.from > coverage.through) {
+    throw new TypeError(`Logical coverage starts after it ends: ${JSON.stringify(coverage)}`);
+  }
+  if (rows === 0) throw new TypeError("Empty partition cannot have non-empty logical coverage");
+}
+function validateQuality(quality, file) {
+  for (const [name, count] of Object.entries(quality)) {
+    if (!Number.isSafeInteger(count) || count < 0) {
+      throw new TypeError(`Invalid provenance ${name}: ${count}`);
+    }
+  }
+  if (quality.writtenRows !== file.rows) {
+    throw new TypeError(
+      `Provenance writtenRows ${quality.writtenRows} does not match file rows ${file.rows}`
+    );
+  }
+  if (quality.inputRows !== quality.writtenRows + quality.droppedRows) {
+    throw new TypeError("Provenance inputRows must equal writtenRows + droppedRows");
+  }
+}
+function validateInput(input) {
+  validateIdentity(input);
+  if (!Number.isSafeInteger(input.schemaRevision) || input.schemaRevision < 1) {
+    throw new TypeError(`Invalid schema revision: ${input.schemaRevision}`);
+  }
+  validateRegistryPath(input, input.relativePath);
+  validateFingerprint(input.file);
+  validateCoverage(input.coverage, input.file.rows);
+  validateQuality(input.quality, input.file);
+  const date = input.partition[canonicalPartitionDataset(input.dataset).provenance.sessionKey];
+  if (input.coverage.kind === "date-range" && (input.coverage.from !== date || input.coverage.through !== date)) {
+    throw new TypeError(
+      `Partition logical coverage must equal its registered date: ${JSON.stringify({ date, coverage: input.coverage })}`
+    );
+  }
+}
+var CANONICAL_PARQUET_SCHEMAS = Object.freeze({
+  spot: [
+    ["ticker", "VARCHAR"],
+    ["date", "VARCHAR"],
+    ["time", "VARCHAR"],
+    ["open", "DOUBLE"],
+    ["high", "DOUBLE"],
+    ["low", "DOUBLE"],
+    ["close", "DOUBLE"],
+    ["bid", "DOUBLE"],
+    ["ask", "DOUBLE"]
+  ],
+  enriched: [
+    ["ticker", "VARCHAR"],
+    ["date", "VARCHAR"],
+    ["Prior_Close", "DOUBLE"],
+    ["Gap_Pct", "DOUBLE"],
+    ["ATR_Pct", "DOUBLE"],
+    ["RSI_14", "DOUBLE"],
+    ["Price_vs_EMA21_Pct", "DOUBLE"],
+    ["Price_vs_SMA50_Pct", "DOUBLE"],
+    ["Realized_Vol_5D", "DOUBLE"],
+    ["Realized_Vol_20D", "DOUBLE"],
+    ["Return_5D", "DOUBLE"],
+    ["Return_20D", "DOUBLE"],
+    ["Intraday_Range_Pct", "DOUBLE"],
+    ["Intraday_Return_Pct", "DOUBLE"],
+    ["Close_Position_In_Range", "DOUBLE"],
+    ["Gap_Filled", "INTEGER"],
+    ["Consecutive_Days", "INTEGER"],
+    ["Prev_Return_Pct", "DOUBLE"],
+    ["Prior_Range_vs_ATR", "DOUBLE"],
+    ["High_Time", "DOUBLE"],
+    ["Low_Time", "DOUBLE"],
+    ["High_Before_Low", "INTEGER"],
+    ["Reversal_Type", "INTEGER"],
+    ["Opening_Drive_Strength", "DOUBLE"],
+    ["Intraday_Realized_Vol", "DOUBLE"],
+    ["Day_of_Week", "INTEGER"],
+    ["Month", "INTEGER"],
+    ["Is_Opex", "INTEGER"],
+    ["ivr", "DOUBLE"],
+    ["ivp", "DOUBLE"]
+  ],
+  enriched_context: [
+    ["date", "VARCHAR"],
+    ["Vol_Regime", "INTEGER"],
+    ["Term_Structure_State", "INTEGER"],
+    ["Trend_Direction", "VARCHAR"],
+    ["VIX_Spike_Pct", "DOUBLE"],
+    ["VIX_Gap_Pct", "DOUBLE"]
+  ],
+  option_chain: [
+    ["underlying", "VARCHAR"],
+    ["date", "VARCHAR"],
+    ["ticker", "VARCHAR"],
+    ["contract_type", "VARCHAR"],
+    ["strike", "DOUBLE"],
+    ["expiration", "VARCHAR"],
+    ["dte", "INTEGER"],
+    ["exercise_style", "VARCHAR"]
+  ],
+  option_quote_minutes: [
+    ["underlying", "VARCHAR"],
+    ["date", "VARCHAR"],
+    ["ticker", "VARCHAR"],
+    ["time", "VARCHAR"],
+    ["bid", "DOUBLE"],
+    ["ask", "DOUBLE"],
+    ["mid", "DOUBLE"],
+    ["last_updated_ns", "BIGINT"],
+    ["source", "VARCHAR"],
+    ["delta", "FLOAT"],
+    ["gamma", "FLOAT"],
+    ["theta", "FLOAT"],
+    ["vega", "FLOAT"],
+    ["iv", "FLOAT"],
+    ["greeks_source", "VARCHAR"],
+    ["greeks_revision", "INTEGER"],
+    ["rate_type", "VARCHAR"],
+    ["rate_value", "DOUBLE"],
+    ["gamma_source", "VARCHAR"]
+  ],
+  option_oi_daily: [
+    ["underlying", "VARCHAR"],
+    ["date", "VARCHAR"],
+    ["ticker", "VARCHAR"],
+    ["expiration", "VARCHAR"],
+    ["strike", "DOUBLE"],
+    ["right", "VARCHAR"],
+    ["open_interest", "BIGINT"],
+    ["source", "VARCHAR"]
+  ]
+});
+function escapeSqlLiteral(value) {
+  return value.replaceAll("'", "''");
+}
+function canonicalDuckDbType(value) {
+  const normalized = String(value).toUpperCase();
+  return normalized === "REAL" ? "FLOAT" : normalized;
+}
+async function inspectCanonicalParquet(conn, filePath, identity) {
+  const expectedSchema = CANONICAL_PARQUET_SCHEMAS[identity.dataset];
+  if (!expectedSchema) throw new TypeError(`No canonical Parquet schema for ${identity.dataset}`);
+  const source = `read_parquet('${escapeSqlLiteral(filePath)}', hive_partitioning=false)`;
+  const described = await conn.runAndReadAll(`DESCRIBE SELECT * FROM ${source}`);
+  const schema = described.getRows().map((row2) => [String(row2[0]), canonicalDuckDbType(row2[1])]);
+  if (canonicalJsonBytes(schema).compare(canonicalJsonBytes(expectedSchema)) !== 0) {
+    throw new Error(
+      `Existing partition Parquet schema does not match revision 1: ${JSON.stringify({ observed: schema, expected: expectedSchema })}`
+    );
+  }
+  const definition = canonicalPartitionDataset(identity.dataset);
+  const sessionColumn = definition.provenance.sessionKey;
+  const predicates = Object.entries(identity.partition).map(
+    ([key, value]) => `COUNT(*) FILTER (WHERE "${key}" IS NULL OR CAST("${key}" AS VARCHAR) <> '${escapeSqlLiteral(value)}')::BIGINT`
+  ).join(", ");
+  const inspected = await conn.runAndReadAll(
+    `SELECT COUNT(*)::BIGINT,
+            COUNT("${sessionColumn}")::BIGINT,
+            MIN(CAST("${sessionColumn}" AS VARCHAR)),
+            MAX(CAST("${sessionColumn}" AS VARCHAR)),
+            ${predicates}
+       FROM ${source}`
+  );
+  const row = inspected.getRows()[0];
+  const rows = Number(row[0]);
+  const coveredRows = Number(row[1]);
+  if (!Number.isSafeInteger(rows) || rows <= 0 || coveredRows !== rows) {
+    throw new Error("Existing canonical Parquet must contain non-null rows for its session");
+  }
+  for (const mismatches of row.slice(4)) {
+    if (Number(mismatches) !== 0) {
+      throw new Error("Existing canonical Parquet rows disagree with the registered partition");
+    }
+  }
+  const from = String(row[2]);
+  const through = String(row[3]);
+  const expectedSession = identity.partition[sessionColumn];
+  if (from !== expectedSession || through !== expectedSession) {
+    throw new Error("Existing canonical Parquet coverage disagrees with its partition session");
+  }
+  return { rows, coverage: { kind: "date-range", from, through } };
+}
+function validateReceipt(receipt, identity) {
+  if (receipt.kind !== PARTITION_COMMIT_RECEIPT_KIND || receipt.version !== PARTITION_COMMIT_RECEIPT_VERSION || receipt.dataset !== identity.dataset || addressCanonicalJson(receipt.partition) !== addressCanonicalJson(identity.partition)) {
+    throw new Error("Partition receipt does not match its identity");
+  }
+  validateInput(receipt);
+  if (receipt.classification !== "append" && receipt.classification !== "repair") {
+    throw new Error(`Invalid partition receipt classification: ${String(receipt.classification)}`);
+  }
+  if (receipt.classification === "append" && receipt.parent !== void 0) {
+    throw new Error("Append receipt must not have a parent");
+  }
+  if (receipt.classification === "repair" && receipt.parent === void 0) {
+    throw new Error("Repair receipt must have a parent");
+  }
+  if (receipt.parent !== void 0) parseCanonicalJsonAddress(receipt.parent);
+}
+function identityAddress(identity) {
+  return addressCanonicalJson({
+    kind: "tradeblocks.market-data.partition-identity",
+    version: 1,
+    dataset: identity.dataset,
+    partition: identity.partition
+  });
+}
+function sameInode(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+async function openRegularFileNoFollow(filePath) {
+  let handle;
+  try {
+    handle = await fs2.open(
+      filePath,
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+  } catch (error) {
+    if (error.code === "ELOOP") {
+      throw new PartitionFileIntegrityError(filePath, "symbolic links are not allowed", error);
+    }
+    throw error;
+  }
+  try {
+    const stat2 = await handle.stat();
+    if (!stat2.isFile()) {
+      throw new PartitionFileIntegrityError(filePath, "expected a regular file");
+    }
+    if (stat2.nlink !== 1) {
+      throw new PartitionFileIntegrityError(filePath, "expected an unshared regular file inode");
+    }
+    return { handle, stat: stat2 };
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+async function exactOpenFileAddress(handle) {
+  const hash = createHash2("sha256");
+  let bytes = 0;
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  while (true) {
+    const read = await handle.read(buffer, 0, buffer.byteLength, bytes);
+    if (read.bytesRead === 0) break;
+    hash.update(buffer.subarray(0, read.bytesRead));
+    bytes += read.bytesRead;
+  }
+  return { address: `sha256:${hash.digest("hex")}`, bytes };
+}
+async function requireNamedRegularInode(filePath, expected) {
+  let named;
+  try {
+    named = await fs2.lstat(filePath);
+  } catch (error) {
+    throw new PartitionFileIntegrityError(
+      filePath,
+      "verified inode is no longer named here",
+      error
+    );
+  }
+  if (!named.isFile()) {
+    throw new PartitionFileIntegrityError(filePath, "canonical entry is not a regular file");
+  }
+  if (named.nlink !== 1 || expected.nlink !== 1) {
+    throw new PartitionFileIntegrityError(filePath, "canonical inode has multiple hard links");
+  }
+  if (!sameInode(expected, named)) {
+    throw new PartitionFileIntegrityError(filePath, "canonical entry changed during verification");
+  }
+}
+async function exactFileAddress(filePath) {
+  const opened = await openRegularFileNoFollow(filePath);
+  try {
+    const fingerprint = await exactOpenFileAddress(opened.handle);
+    const after = await opened.handle.stat();
+    if (!after.isFile() || after.nlink !== 1 || !sameInode(opened.stat, after)) {
+      throw new PartitionFileIntegrityError(filePath, "open inode changed during verification");
+    }
+    await requireNamedRegularInode(filePath, opened.stat);
+    return fingerprint;
+  } finally {
+    await opened.handle.close();
+  }
+}
+async function snapshotOpenFile(source, snapshotPath) {
+  const snapshot = await fs2.open(snapshotPath, "wx", 256);
+  const hash = createHash2("sha256");
+  let bytes = 0;
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  try {
+    while (true) {
+      const read = await source.read(buffer, 0, buffer.byteLength, bytes);
+      if (read.bytesRead === 0) break;
+      hash.update(buffer.subarray(0, read.bytesRead));
+      let written = 0;
+      while (written < read.bytesRead) {
+        const result = await snapshot.write(
+          buffer,
+          written,
+          read.bytesRead - written,
+          bytes + written
+        );
+        if (result.bytesWritten === 0) throw new Error("Unable to write inspection snapshot");
+        written += result.bytesWritten;
+      }
+      bytes += read.bytesRead;
+    }
+    await snapshot.sync();
+  } finally {
+    await snapshot.close();
+  }
+  return { address: `sha256:${hash.digest("hex")}`, bytes };
+}
+function sameCommitContent(previous, input) {
+  return previous.schemaRevision === input.schemaRevision && previous.relativePath === input.relativePath && addressCanonicalJson(previous.coverage) === addressCanonicalJson(input.coverage) && addressCanonicalJson(previous.quality) === addressCanonicalJson(input.quality) && previous.file.address === input.file.address && previous.file.bytes === input.file.bytes && previous.file.rows === input.file.rows;
+}
+function captureIdentity(identity) {
+  const captured = JSON.parse(
+    canonicalJsonBytes({ dataset: identity.dataset, partition: identity.partition }).toString(
+      "utf8"
+    )
+  );
+  validateIdentity(captured);
+  return Object.freeze({ ...captured, partition: Object.freeze(captured.partition) });
+}
+function captureInput(input) {
+  const captured = JSON.parse(
+    canonicalJsonBytes({
+      dataset: input.dataset,
+      partition: input.partition,
+      schemaRevision: input.schemaRevision,
+      relativePath: input.relativePath,
+      coverage: input.coverage,
+      quality: input.quality,
+      file: input.file
+    }).toString("utf8")
+  );
+  validateInput(captured);
+  Object.freeze(captured.partition);
+  Object.freeze(captured.coverage);
+  Object.freeze(captured.quality);
+  Object.freeze(captured.file);
+  return Object.freeze(captured);
+}
+var FilePartitionCommitStore = class {
+  marketRootDir;
+  objects;
+  provenanceRootDir;
+  staleLockMs;
+  lockWaitMs;
+  constructor(marketRootDir, options = {}) {
+    this.marketRootDir = marketRootDir;
+    this.provenanceRootDir = path3.join(marketRootDir, ".provenance");
+    this.objects = new ContentObjectStore(this.provenanceRootDir);
+    this.staleLockMs = options.staleLockMs ?? 3e4;
+    this.lockWaitMs = options.lockWaitMs ?? 5e3;
+  }
+  identityDigest(identity) {
+    return parseCanonicalJsonAddress(identityAddress(identity));
+  }
+  headPath(identity) {
+    const digest = this.identityDigest(identity);
+    return path3.join(this.provenanceRootDir, "heads", digest.slice(0, 2), `${digest}.json`);
+  }
+  eventIndexDir(identity) {
+    const digest = this.identityDigest(identity);
+    return path3.join(this.provenanceRootDir, "events", digest.slice(0, 2), digest);
+  }
+  lockRoot(identity) {
+    const digest = this.identityDigest(identity);
+    return path3.join(this.provenanceRootDir, "locks", digest.slice(0, 2), digest);
+  }
+  targetPath(relativePath) {
+    validateRelativePath(relativePath);
+    return path3.join(this.marketRootDir, ...relativePath.split("/"));
+  }
+  async validateMarketRoot() {
+    const root = path3.resolve(this.marketRootDir);
+    const rootStat = await fs2.lstat(root);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+      throw new PartitionFileIntegrityError(root, "market root must be a real directory");
+    }
+    return fs2.realpath(root);
+  }
+  async validatedTargetPath(relativePath, expectedRealRoot) {
+    validateRelativePath(relativePath);
+    const root = path3.resolve(this.marketRootDir);
+    const realRoot = await this.validateMarketRoot();
+    if (realRoot !== expectedRealRoot) {
+      throw new PartitionFileIntegrityError(root, "market root changed during publication");
+    }
+    const components = relativePath.split("/");
+    let current = root;
+    for (const component of components.slice(0, -1)) {
+      current = path3.join(current, component);
+      const stat2 = await fs2.lstat(current);
+      if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
+        throw new PartitionFileIntegrityError(
+          current,
+          "target path components must be real directories"
+        );
+      }
+    }
+    const realParent = await fs2.realpath(current);
+    const containment = path3.relative(realRoot, realParent);
+    if (containment === ".." || containment.startsWith(`..${path3.sep}`) || path3.isAbsolute(containment)) {
+      throw new PartitionFileIntegrityError(
+        current,
+        "target parent escapes the configured market root"
+      );
+    }
+    return path3.join(current, components.at(-1));
+  }
+  async quarantineClaim(claimedPath) {
+    try {
+      await fs2.lstat(claimedPath);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const quarantineDir = path3.join(this.provenanceRootDir, "rejected-prepared");
+    await this.ensureDurableDirectory(quarantineDir);
+    const quarantinePath = path3.join(quarantineDir, randomUUID2());
+    await fs2.rename(claimedPath, quarantinePath);
+    await this.syncDirectory(path3.dirname(claimedPath));
+    await this.syncDirectory(quarantineDir);
+  }
+  async restoreOrQuarantineClaim(claimedPath, preparedPath) {
+    let restored = false;
+    let claimedRemoved = false;
+    try {
+      await fs2.link(claimedPath, preparedPath);
+      restored = true;
+      await fs2.unlink(claimedPath);
+      claimedRemoved = true;
+      await this.syncDirectory(path3.dirname(preparedPath));
+      return;
+    } catch (error) {
+      if (claimedRemoved) throw error;
+      if (restored) await fs2.unlink(preparedPath).catch(() => void 0);
+      await this.quarantineClaim(claimedPath);
+    }
+  }
+  async syncDirectory(directory) {
+    const handle = await fs2.open(directory, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  async ensureDurableDirectory(directory) {
+    const parent = path3.dirname(directory);
+    if (parent !== directory) await this.ensureDurableDirectory(parent);
+    try {
+      const handle = await fs2.open(directory, "r");
+      try {
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      if (parent !== directory) await this.syncDirectory(parent);
+      return;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (parent === directory) throw new Error(`Cannot create provenance directory ${directory}`);
+    let created = false;
+    try {
+      await fs2.mkdir(directory);
+      created = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    if (created) {
+      await this.syncDirectory(directory);
+      await this.syncDirectory(parent);
+    }
+  }
+  isProcessAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  }
+  async readCanonicalFile(filePath) {
+    try {
+      const bytes = await fs2.readFile(filePath);
+      const value = JSON.parse(bytes.toString("utf8"));
+      if (!canonicalJsonBytes(value).equals(bytes)) return null;
+      return value;
+    } catch {
+      return null;
+    }
+  }
+  validOwner(owner, token) {
+    return Boolean(
+      owner && owner.kind === "tradeblocks.market-data.partition-lock-owner" && owner.version === 1 && owner.token === token && TOKEN_RE.test(owner.token) && Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.hostname === "string" && owner.hostname.length > 0 && typeof owner.bootId === "string" && owner.bootId.length > 0 && Number.isSafeInteger(owner.createdAtMs) && owner.createdAtMs >= 0
+    );
+  }
+  validTicket(ticket, token) {
+    return Boolean(
+      ticket && ticket.kind === "tradeblocks.market-data.partition-lock-ticket" && ticket.version === 1 && ticket.token === token && Number.isSafeInteger(ticket.number) && ticket.number >= 1
+    );
+  }
+  ownerProvablyDead(owner) {
+    if (owner.hostname !== CURRENT_HOSTNAME) return false;
+    if (owner.bootId !== "unavailable" && CURRENT_BOOT_ID !== "unavailable" && owner.bootId !== CURRENT_BOOT_ID) {
+      return true;
+    }
+    return !this.isProcessAlive(owner.pid);
+  }
+  async recoverClaim(claimsDir, token) {
+    if (!TOKEN_RE.test(token)) return false;
+    const claimPath = path3.join(claimsDir, token);
+    let claimStat;
+    try {
+      claimStat = await fs2.stat(claimPath);
+    } catch (error) {
+      if (error.code === "ENOENT") return true;
+      throw error;
+    }
+    const owner = await this.readCanonicalFile(
+      path3.join(claimPath, "owner.json")
+    );
+    const validOwner = this.validOwner(owner, token);
+    if (!validOwner) return false;
+    const createdAtMs = owner.createdAtMs;
+    if (Date.now() - createdAtMs < this.staleLockMs) return false;
+    if (!this.ownerProvablyDead(owner)) return false;
+    const quarantineDir = path3.join(path3.dirname(claimsDir), "quarantine");
+    await this.ensureDurableDirectory(quarantineDir);
+    const quarantinePath = path3.join(
+      quarantineDir,
+      `${token}-${claimStat.ino}-${Math.floor(claimStat.birthtimeMs)}`
+    );
+    try {
+      await fs2.rename(claimPath, quarantinePath);
+      await this.syncDirectory(claimsDir);
+      await this.syncDirectory(quarantineDir);
+      return true;
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "EEXIST" || code === "ENOTEMPTY") return false;
+      throw error;
+    }
+  }
+  async publishClaim(claimsDir, token) {
+    const owner = {
+      kind: "tradeblocks.market-data.partition-lock-owner",
+      version: 1,
+      token,
+      pid: process.pid,
+      hostname: CURRENT_HOSTNAME,
+      bootId: CURRENT_BOOT_ID,
+      createdAtMs: Date.now()
+    };
+    const publishingPath = path3.join(claimsDir, `.publishing-${token}`);
+    const claimPath = path3.join(claimsDir, token);
+    await fs2.mkdir(publishingPath);
+    try {
+      const ownerHandle = await fs2.open(path3.join(publishingPath, "owner.json"), "wx", 292);
+      try {
+        await ownerHandle.writeFile(canonicalJsonBytes(owner));
+        await ownerHandle.sync();
+      } finally {
+        await ownerHandle.close();
+      }
+      await this.syncDirectory(publishingPath);
+      await fs2.rename(publishingPath, claimPath);
+      await this.syncDirectory(claimsDir);
+      return claimPath;
+    } catch (error) {
+      await fs2.rm(publishingPath, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async assignTicket(claimsDir, claimPath, token) {
+    let maximum = 0;
+    for (const entry of await fs2.readdir(claimsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !TOKEN_RE.test(entry.name)) continue;
+      const ticket2 = await this.readCanonicalFile(
+        path3.join(claimsDir, entry.name, "ticket.json")
+      );
+      if (this.validTicket(ticket2, entry.name)) maximum = Math.max(maximum, ticket2.number);
+    }
+    if (!Number.isSafeInteger(maximum + 1)) throw new Error("Partition lock ticket overflow");
+    const ticket = {
+      kind: "tradeblocks.market-data.partition-lock-ticket",
+      version: 1,
+      token,
+      number: maximum + 1
+    };
+    const handle = await fs2.open(path3.join(claimPath, "ticket.json"), "wx", 292);
+    try {
+      await handle.writeFile(canonicalJsonBytes(ticket));
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await this.syncDirectory(claimPath);
+    return ticket.number;
+  }
+  async releaseClaim(claimsDir, claimPath, token) {
+    await partitionCommitTestFaults.get(this)?.("before-release-claim");
+    const owner = await this.readCanonicalFile(
+      path3.join(claimPath, "owner.json")
+    );
+    if (!this.validOwner(owner, token) || owner.pid !== process.pid) {
+      throw new Error(
+        `Refusing to release a partition claim owned by another writer: ${claimPath}`
+      );
+    }
+    const releasedDir = path3.join(path3.dirname(claimsDir), "released");
+    await this.ensureDurableDirectory(releasedDir);
+    const releasedPath = path3.join(releasedDir, token);
+    await fs2.rename(claimPath, releasedPath);
+    await this.syncDirectory(claimsDir);
+    await this.syncDirectory(releasedDir);
+    await fs2.rm(releasedPath, { recursive: true });
+    await this.syncDirectory(releasedDir);
+  }
+  async withPartitionLock(identity, operation) {
+    validateIdentity(identity);
+    const lockRoot = this.lockRoot(identity);
+    const claimsDir = path3.join(lockRoot, "claims");
+    await this.ensureDurableDirectory(claimsDir);
+    const token = randomUUID2();
+    const claimPath = await this.publishClaim(claimsDir, token);
+    let ownTicket;
+    try {
+      ownTicket = await this.assignTicket(claimsDir, claimPath, token);
+    } catch (error) {
+      try {
+        await this.releaseClaim(claimsDir, claimPath, token);
+      } catch (cleanupError) {
+        throw attachPartitionLockCleanupError(error, cleanupError);
+      }
+      throw error;
+    }
+    const deadline = Date.now() + this.lockWaitMs;
+    let acquired = false;
+    let operationFailed = false;
+    let operationError;
+    try {
+      while (Date.now() <= deadline) {
+        let blocked = false;
+        const entries = await fs2.readdir(claimsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory() || entry.name === token) continue;
+          if (!TOKEN_RE.test(entry.name)) {
+            if (!entry.name.startsWith(".publishing-")) blocked = true;
+            continue;
+          }
+          const otherPath = path3.join(claimsDir, entry.name);
+          const owner = await this.readCanonicalFile(
+            path3.join(otherPath, "owner.json")
+          );
+          if (!this.validOwner(owner, entry.name)) {
+            blocked = true;
+            continue;
+          }
+          const ticket = await this.readCanonicalFile(
+            path3.join(otherPath, "ticket.json")
+          );
+          if (!this.validTicket(ticket, entry.name)) {
+            try {
+              await fs2.stat(path3.join(otherPath, "ticket.json"));
+              blocked = true;
+            } catch (error) {
+              if (error.code !== "ENOENT") throw error;
+              if (!await this.recoverClaim(claimsDir, entry.name)) blocked = true;
+            }
+            continue;
+          }
+          if (ticket.number < ownTicket || ticket.number === ownTicket && entry.name < token) {
+            if (!await this.recoverClaim(claimsDir, entry.name)) blocked = true;
+          }
+        }
+        if (!blocked) {
+          acquired = true;
+          break;
+        }
+        await new Promise((resolve3) => setTimeout(resolve3, 10));
+      }
+      if (!acquired) throw new Error(`Timed out acquiring partition lock: ${lockRoot}`);
+      return await operation();
+    } catch (error) {
+      operationFailed = true;
+      operationError = error;
+      throw error;
+    } finally {
+      try {
+        await this.releaseClaim(claimsDir, claimPath, token);
+      } catch (cleanupError) {
+        if (operationFailed) {
+          throw attachPartitionLockCleanupError(operationError, cleanupError);
+        }
+        throw cleanupError;
+      }
+    }
+  }
+  async readIndexedEvent(identity, eventPath, address) {
+    const bytes = await fs2.readFile(eventPath);
+    if (addressBytes(bytes) !== address) {
+      throw new ContentObjectCollisionError(address, eventPath);
+    }
+    const event = JSON.parse(bytes.toString("utf8"));
+    if (!canonicalJsonBytes(event).equals(bytes)) {
+      throw new ContentObjectCollisionError(address, eventPath);
+    }
+    if (event.kind !== PARTITION_COMMIT_EVENT_KIND || event.version !== PARTITION_COMMIT_EVENT_VERSION || event.dataset !== identity.dataset || addressCanonicalJson(event.partition) !== addressCanonicalJson(identity.partition)) {
+      throw new Error(`Invalid partition commit event at ${eventPath}`);
+    }
+    parseCanonicalJsonAddress(event.receipt);
+    if (event.previous !== void 0) parseCanonicalJsonAddress(event.previous);
+    const commit = await this.readCommit(event.receipt);
+    validateReceipt(commit.receipt, identity);
+    return { event, commit };
+  }
+  async readAuthorityTip(identity) {
+    const indexDir = this.eventIndexDir(identity);
+    let entries;
+    try {
+      entries = await fs2.readdir(indexDir);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+    const events = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const match = /^([0-9a-f]{64})\.json$/.exec(entry);
+      if (!match) throw new Error(`Unexpected partition event index entry: ${entry}`);
+      const address = `sha256:${match[1]}`;
+      events.set(
+        address,
+        await this.readIndexedEvent(identity, path3.join(indexDir, entry), address)
+      );
+    }
+    if (events.size === 0) return null;
+    const roots = [...events.entries()].filter(([, value]) => value.event.previous === void 0);
+    if (roots.length !== 1) throw new Error("Partition event authority must have exactly one root");
+    let [currentAddress, current] = roots[0];
+    if (current.commit.receipt.classification !== "append") {
+      throw new Error("Partition event root must reference an append receipt");
+    }
+    const visited = /* @__PURE__ */ new Set();
+    while (true) {
+      if (visited.has(currentAddress))
+        throw new Error("Partition event authority contains a cycle");
+      visited.add(currentAddress);
+      const children = [...events.entries()].filter(
+        ([, value]) => value.event.previous === currentAddress
+      );
+      if (children.length === 0) break;
+      if (children.length !== 1)
+        throw new Error("Partition event authority contains ambiguous tips");
+      const [childAddress, child] = children[0];
+      if (child.commit.receipt.classification !== "repair" || child.commit.receipt.parent !== current.commit.address) {
+        throw new Error("Partition event authority receipt ancestry is inconsistent");
+      }
+      currentAddress = childAddress;
+      current = child;
+    }
+    if (visited.size !== events.size) {
+      throw new Error("Partition event authority contains a disconnected or missing-parent event");
+    }
+    return { eventAddress: currentAddress, commit: current.commit };
+  }
+  async readProjectedHead(identity) {
+    const headPath = this.headPath(identity);
+    let bytes;
+    try {
+      bytes = await fs2.readFile(headPath);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+    try {
+      const head = JSON.parse(bytes.toString("utf8"));
+      if (!canonicalJsonBytes(head).equals(bytes)) return null;
+      if (head.kind !== PARTITION_HEAD_KIND || head.version !== PARTITION_HEAD_VERSION || head.dataset !== identity.dataset || addressCanonicalJson(head.partition) !== addressCanonicalJson(identity.partition)) {
+        return null;
+      }
+      parseCanonicalJsonAddress(head.receipt);
+      parseCanonicalJsonAddress(head.event);
+      return head;
+    } catch {
+      return null;
+    }
+  }
+  async writeHead(identity, tip) {
+    const headPath = this.headPath(identity);
+    await this.ensureDurableDirectory(path3.dirname(headPath));
+    const tempPath = `${headPath}.tmp-${randomUUID2()}`;
+    const head = {
+      kind: PARTITION_HEAD_KIND,
+      version: PARTITION_HEAD_VERSION,
+      dataset: identity.dataset,
+      partition: identity.partition,
+      receipt: tip.commit.address,
+      event: tip.eventAddress
+    };
+    let handle;
+    try {
+      handle = await fs2.open(tempPath, "wx", 420);
+      await handle.writeFile(canonicalJsonBytes(head));
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      await fs2.rename(tempPath, headPath);
+      await this.syncDirectory(path3.dirname(headPath));
+    } catch (error) {
+      await handle?.close();
+      await fs2.unlink(tempPath).catch(() => void 0);
+      throw error;
+    }
+  }
+  async authorityWithRebuiltHead(identity) {
+    const tip = await this.readAuthorityTip(identity);
+    const head = await this.readProjectedHead(identity);
+    if (!tip) {
+      if (head) throw new Error("Partition head exists without immutable event authority");
+      return null;
+    }
+    if (head?.receipt !== tip.commit.address || head.event !== tip.eventAddress) {
+      await this.writeHead(identity, tip);
+    }
+    return tip;
+  }
+  async appendEvent(identity, receipt, previous) {
+    const event = {
+      kind: PARTITION_COMMIT_EVENT_KIND,
+      version: PARTITION_COMMIT_EVENT_VERSION,
+      dataset: identity.dataset,
+      partition: identity.partition,
+      receipt,
+      ...previous ? { previous } : {}
+    };
+    const stored = await this.objects.put(event);
+    const indexDir = this.eventIndexDir(identity);
+    await this.ensureDurableDirectory(indexDir);
+    const digest = parseCanonicalJsonAddress(stored.address);
+    const eventPath = path3.join(indexDir, `${digest}.json`);
+    try {
+      await fs2.link(stored.path, eventPath);
+      await this.syncDirectory(indexDir);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const existing = await fs2.readFile(eventPath);
+      if (addressBytes(existing) !== stored.address || !existing.equals(canonicalJsonBytes(event))) {
+        throw new ContentObjectCollisionError(stored.address, eventPath);
+      }
+      const handle = await fs2.open(eventPath, "r");
+      try {
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await this.syncDirectory(indexDir);
+    }
+    return stored.address;
+  }
+  async readCommit(address) {
+    parseCanonicalJsonAddress(address);
+    const receipt = await this.objects.get(address);
+    validateReceipt(receipt, receipt);
+    return Object.freeze({ address, receipt, created: false });
+  }
+  /**
+   * Adopt an existing canonical Parquet partition after producer-owned schema,
+   * identity, coverage, row-count, and exact-byte inspection.
+   */
+  async [INTERNAL_HISTORICAL_PARTITION_ADOPTION](conn, identity) {
+    const captured = captureIdentity(identity);
+    const definition = canonicalPartitionDataset(captured.dataset);
+    const relativePath = canonicalRelativePath(captured);
+    const targetPath = path3.resolve(this.targetPath(relativePath));
+    return this.withPartitionLock(captured, async () => {
+      const realMarketRoot = await this.validateMarketRoot();
+      const validatedTargetPath = await this.validatedTargetPath(relativePath, realMarketRoot);
+      if (validatedTargetPath !== targetPath) {
+        throw new PartitionFileIntegrityError(
+          validatedTargetPath,
+          "validated target differs from the registered path"
+        );
+      }
+      const opened = await openRegularFileNoFollow(targetPath);
+      const snapshotRoot = path3.join(this.provenanceRootDir, "inspection-snapshots");
+      await this.ensureDurableDirectory(snapshotRoot);
+      const snapshotDir = await fs2.mkdtemp(path3.join(snapshotRoot, "adopt-"));
+      const snapshotPath = path3.join(snapshotDir, "partition.parquet");
+      try {
+        const snapshotFingerprint = await snapshotOpenFile(opened.handle, snapshotPath);
+        const snapshotObserved = await exactFileAddress(snapshotPath);
+        if (snapshotObserved.address !== snapshotFingerprint.address || snapshotObserved.bytes !== snapshotFingerprint.bytes) {
+          throw new PartitionFileIntegrityError(
+            snapshotPath,
+            "inspection snapshot bytes disagree with the pinned canonical inode"
+          );
+        }
+        await partitionCommitTestFaults.get(this)?.("historical-after-snapshot");
+        const inspected = await inspectCanonicalParquet(conn, snapshotPath, captured);
+        const snapshotAfter = await exactFileAddress(snapshotPath);
+        if (snapshotAfter.address !== snapshotFingerprint.address || snapshotAfter.bytes !== snapshotFingerprint.bytes) {
+          throw new PartitionFileIntegrityError(
+            snapshotPath,
+            "inspection snapshot changed during semantic inspection"
+          );
+        }
+        const canonicalAfter = await exactOpenFileAddress(opened.handle);
+        const afterStat = await opened.handle.stat();
+        if (!afterStat.isFile() || afterStat.nlink !== 1 || !sameInode(opened.stat, afterStat) || canonicalAfter.address !== snapshotFingerprint.address || canonicalAfter.bytes !== snapshotFingerprint.bytes) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "canonical inode changed during historical semantic inspection"
+          );
+        }
+        await requireNamedRegularInode(targetPath, opened.stat);
+        return this.adoptExistingFileCommit(
+          {
+            dataset: captured.dataset,
+            partition: captured.partition,
+            schemaRevision: definition.schemaRevision,
+            relativePath,
+            coverage: inspected.coverage,
+            quality: { inputRows: inspected.rows, writtenRows: inspected.rows, droppedRows: 0 },
+            file: { ...snapshotFingerprint, rows: inspected.rows }
+          },
+          true
+        );
+      } finally {
+        await opened.handle.close();
+        await fs2.rm(snapshotDir, { recursive: true });
+      }
+    });
+  }
+  /**
+   * Establish immutable authority for a canonical file that predates receipt
+   * publication. This never replaces the data file: it pins and hashes the
+   * existing regular inode under the partition lock, then appends authority
+   * only when the caller-supplied rows/coverage/fingerprint agree exactly.
+   */
+  async adoptExistingFileCommit(input, lockHeld = false) {
+    const captured = captureInput(input);
+    const targetPath = path3.resolve(this.targetPath(captured.relativePath));
+    const realMarketRoot = await this.validateMarketRoot();
+    const adopt = async () => {
+      const validatedTargetPath = await this.validatedTargetPath(
+        captured.relativePath,
+        realMarketRoot
+      );
+      if (validatedTargetPath !== targetPath) {
+        throw new PartitionFileIntegrityError(
+          validatedTargetPath,
+          "validated target differs from the registered path"
+        );
+      }
+      const opened = await openRegularFileNoFollow(targetPath);
+      const handle = opened.handle;
+      const pinnedStat = opened.stat;
+      try {
+        if (await this.validatedTargetPath(captured.relativePath, realMarketRoot) !== targetPath) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "target parent changed before existing-file adoption"
+          );
+        }
+        const observed = await exactOpenFileAddress(handle);
+        const afterHash = await handle.stat();
+        if (!afterHash.isFile() || afterHash.nlink !== 1 || !sameInode(pinnedStat, afterHash)) {
+          throw new PartitionFileIntegrityError(targetPath, "existing inode changed while hashing");
+        }
+        await requireNamedRegularInode(targetPath, pinnedStat);
+        if (observed.address !== captured.file.address || observed.bytes !== captured.file.bytes) {
+          throw new Error("Existing partition bytes do not match the supplied fingerprint");
+        }
+        const previous = await this.authorityWithRebuiltHead(captured);
+        if (previous && sameCommitContent(previous.commit.receipt, captured)) {
+          return previous.commit;
+        }
+        const receipt = {
+          kind: PARTITION_COMMIT_RECEIPT_KIND,
+          version: PARTITION_COMMIT_RECEIPT_VERSION,
+          schemaRevision: captured.schemaRevision,
+          dataset: captured.dataset,
+          partition: captured.partition,
+          relativePath: captured.relativePath,
+          coverage: captured.coverage,
+          quality: captured.quality,
+          file: captured.file,
+          classification: previous ? "repair" : "append",
+          ...previous ? { parent: previous.commit.address } : {}
+        };
+        const published = await this.objects.put(receipt);
+        const stored = Object.freeze({
+          address: published.address,
+          receipt: published.value,
+          created: published.created
+        });
+        if (await this.validatedTargetPath(captured.relativePath, realMarketRoot) !== targetPath) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "target parent changed before authority publication"
+          );
+        }
+        await requireNamedRegularInode(targetPath, pinnedStat);
+        const beforeEvent = await exactOpenFileAddress(handle);
+        if (beforeEvent.address !== stored.receipt.file.address || beforeEvent.bytes !== stored.receipt.file.bytes) {
+          throw new Error("Existing partition changed before authority publication");
+        }
+        const eventAddress = await this.appendEvent(
+          captured,
+          stored.address,
+          previous?.eventAddress
+        );
+        await this.writeHead(captured, { eventAddress, commit: stored });
+        if (await this.validatedTargetPath(captured.relativePath, realMarketRoot) !== targetPath) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "target parent changed during authority publication"
+          );
+        }
+        await requireNamedRegularInode(targetPath, pinnedStat);
+        const finalObserved = await exactOpenFileAddress(handle);
+        const afterFinalHash = await handle.stat();
+        if (!afterFinalHash.isFile() || afterFinalHash.nlink !== 1 || !sameInode(pinnedStat, afterFinalHash)) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "existing inode changed during final verification"
+          );
+        }
+        await requireNamedRegularInode(targetPath, pinnedStat);
+        if (finalObserved.address !== stored.receipt.file.address || finalObserved.bytes !== stored.receipt.file.bytes) {
+          throw new Error("Existing partition changed during authority publication");
+        }
+        return stored;
+      } finally {
+        await handle.close();
+      }
+    };
+    return lockHeld ? adopt() : this.withPartitionLock(captured, adopt);
+  }
+  async publishFileCommit(input) {
+    const captured = captureInput(input);
+    const preparedPath = path3.resolve(String(input.preparedPath));
+    const expectedTargetPath = path3.resolve(String(input.expectedTargetPath));
+    const targetPath = path3.resolve(this.targetPath(captured.relativePath));
+    if (expectedTargetPath !== targetPath) {
+      throw new TypeError(
+        `Provenance target does not match the store-owned market path: ${JSON.stringify({ expected: targetPath, observed: expectedTargetPath })}`
+      );
+    }
+    if (preparedPath === targetPath || path3.dirname(preparedPath) !== path3.dirname(targetPath)) {
+      throw new TypeError("Prepared partition file must be a distinct sibling of its target");
+    }
+    const realMarketRoot = await this.validateMarketRoot();
+    return this.withPartitionLock(captured, async () => {
+      const validatedTargetPath = await this.validatedTargetPath(
+        captured.relativePath,
+        realMarketRoot
+      );
+      if (validatedTargetPath !== targetPath) {
+        throw new PartitionFileIntegrityError(
+          validatedTargetPath,
+          "validated target differs from the registered path"
+        );
+      }
+      const targetDirectory = path3.dirname(targetPath);
+      const claimedPath = path3.join(targetDirectory, `.provenance-claim-${randomUUID2()}`);
+      let claimed = false;
+      let targetTouched = false;
+      let claimedHandle;
+      let claimedStat;
+      try {
+        await fs2.rename(preparedPath, claimedPath);
+        claimed = true;
+        await this.syncDirectory(targetDirectory);
+        const opened = await openRegularFileNoFollow(claimedPath);
+        claimedHandle = opened.handle;
+        claimedStat = opened.stat;
+        await partitionCommitTestFaults.get(this)?.("after-claim-open");
+        const prepared = await exactOpenFileAddress(claimedHandle);
+        const afterPreparedHash = await claimedHandle.stat();
+        if (!afterPreparedHash.isFile() || afterPreparedHash.nlink !== 1 || !sameInode(claimedStat, afterPreparedHash)) {
+          throw new PartitionFileIntegrityError(claimedPath, "claimed inode changed while hashing");
+        }
+        await requireNamedRegularInode(claimedPath, claimedStat);
+        if (prepared.address !== captured.file.address || prepared.bytes !== captured.file.bytes) {
+          throw new Error("Prepared partition bytes do not match the supplied fingerprint");
+        }
+        await claimedHandle.sync();
+        await this.syncDirectory(targetDirectory);
+        const previous = await this.authorityWithRebuiltHead(captured);
+        let stored;
+        let pendingEvent;
+        if (previous && sameCommitContent(previous.commit.receipt, captured)) {
+          stored = previous.commit;
+        } else {
+          const receipt = {
+            kind: PARTITION_COMMIT_RECEIPT_KIND,
+            version: PARTITION_COMMIT_RECEIPT_VERSION,
+            schemaRevision: captured.schemaRevision,
+            dataset: captured.dataset,
+            partition: captured.partition,
+            relativePath: captured.relativePath,
+            coverage: captured.coverage,
+            quality: captured.quality,
+            file: captured.file,
+            classification: previous ? "repair" : "append",
+            ...previous ? { parent: previous.commit.address } : {}
+          };
+          const publishedReceipt = await this.objects.put(receipt);
+          stored = {
+            address: publishedReceipt.address,
+            receipt: publishedReceipt.value,
+            created: publishedReceipt.created
+          };
+          Object.freeze(stored);
+          pendingEvent = { receipt: stored, previousEvent: previous?.eventAddress };
+        }
+        if (await this.validatedTargetPath(captured.relativePath, realMarketRoot) !== targetPath) {
+          throw new PartitionFileIntegrityError(targetPath, "target parent changed before install");
+        }
+        const beforeInstall = await claimedHandle.stat();
+        if (!beforeInstall.isFile() || beforeInstall.nlink !== 1 || !sameInode(claimedStat, beforeInstall)) {
+          throw new PartitionFileIntegrityError(
+            claimedPath,
+            "claimed inode changed before install"
+          );
+        }
+        await requireNamedRegularInode(claimedPath, claimedStat);
+        await fs2.rename(claimedPath, targetPath);
+        claimed = false;
+        targetTouched = true;
+        await this.syncDirectory(targetDirectory);
+        await requireNamedRegularInode(targetPath, claimedStat);
+        const afterInstall = await claimedHandle.stat();
+        if (!afterInstall.isFile() || afterInstall.nlink !== 1 || !sameInode(claimedStat, afterInstall)) {
+          throw new PartitionFileIntegrityError(targetPath, "installed inode changed");
+        }
+        const observed = await exactOpenFileAddress(claimedHandle);
+        const afterInstalledHash = await claimedHandle.stat();
+        if (!afterInstalledHash.isFile() || afterInstalledHash.nlink !== 1 || !sameInode(claimedStat, afterInstalledHash)) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "installed inode changed while hashing"
+          );
+        }
+        await requireNamedRegularInode(targetPath, claimedStat);
+        await claimedHandle.sync();
+        if (observed.address !== stored.receipt.file.address || observed.bytes !== stored.receipt.file.bytes) {
+          throw new Error("Installed partition bytes disagree with immutable commit authority");
+        }
+        if (pendingEvent) {
+          const eventAddress = await this.appendEvent(
+            captured,
+            pendingEvent.receipt.address,
+            pendingEvent.previousEvent
+          );
+          await partitionCommitTestFaults.get(this)?.("after-event-before-head");
+          await this.writeHead(captured, { eventAddress, commit: pendingEvent.receipt });
+        }
+        const tip = await this.authorityWithRebuiltHead(captured);
+        if (!tip || tip.commit.address !== stored.address) {
+          throw new Error("Installed partition and authoritative head disagree");
+        }
+        if (await this.validatedTargetPath(captured.relativePath, realMarketRoot) !== targetPath) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "target parent changed before publication completed"
+          );
+        }
+        const beforeReturn = await claimedHandle.stat();
+        if (!beforeReturn.isFile() || beforeReturn.nlink !== 1 || !sameInode(claimedStat, beforeReturn)) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "installed inode changed before publication completed"
+          );
+        }
+        await requireNamedRegularInode(targetPath, claimedStat);
+        const finalObserved = await exactOpenFileAddress(claimedHandle);
+        const afterFinalHash = await claimedHandle.stat();
+        if (!afterFinalHash.isFile() || afterFinalHash.nlink !== 1 || !sameInode(claimedStat, afterFinalHash)) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "installed inode changed during final verification"
+          );
+        }
+        await requireNamedRegularInode(targetPath, claimedStat);
+        if (finalObserved.address !== stored.receipt.file.address || finalObserved.bytes !== stored.receipt.file.bytes) {
+          throw new Error("Installed partition changed before publication completed");
+        }
+        return stored;
+      } catch (error) {
+        if (targetTouched) {
+          throw new PartitionFilePublicationError(targetPath, captured.file, error);
+        }
+        throw error;
+      } finally {
+        await claimedHandle?.close();
+        if (claimed) await this.restoreOrQuarantineClaim(claimedPath, preparedPath);
+      }
+    });
+  }
+  async inspectPartition(identity) {
+    const captured = captureIdentity(identity);
+    const realMarketRoot = await this.validateMarketRoot();
+    return this.withPartitionLock(captured, async () => {
+      const tip = await this.authorityWithRebuiltHead(captured);
+      const relativePath = tip?.commit.receipt.relativePath ?? canonicalRelativePath(captured);
+      validateRegistryPath(captured, relativePath);
+      let observed;
+      try {
+        const targetPath = await this.validatedTargetPath(relativePath, realMarketRoot);
+        observed = await exactFileAddress(targetPath);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return tip ? { status: "missing", receipt: tip.commit } : { status: "absent" };
+        }
+        throw error;
+      }
+      if (!tip) return { status: "orphan", observed };
+      if (tip.commit.receipt.file.address !== observed.address || tip.commit.receipt.file.bytes !== observed.bytes) {
+        return { status: "mismatch", receipt: tip.commit, observed };
+      }
+      return { status: "match", receipt: tip.commit };
+    });
+  }
+};
+async function publishRefreshCompletionAuthority(store, completion) {
+  const digest = parseCanonicalJsonAddress(completion);
+  const source = store.objects.objectPath(completion);
+  const directory = path3.join(store.provenanceRootDir, "refresh-completions", digest.slice(0, 2));
+  const marker = path3.join(directory, `${digest}.json`);
+  await fs2.mkdir(directory, { recursive: true });
+  try {
+    await fs2.link(source, marker);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const bytes = await fs2.readFile(marker);
+  if (addressBytes(bytes) !== completion) {
+    throw new ContentObjectCollisionError(completion, marker);
+  }
+  const handle = await fs2.open(marker, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  const directoryHandle = await fs2.open(directory, "r");
+  try {
+    await directoryHandle.sync();
+  } finally {
+    await directoryHandle.close();
+  }
+}
+async function verifyRefreshCompletionAuthority(store, completion) {
+  const digest = parseCanonicalJsonAddress(completion);
+  const marker = path3.join(
+    store.provenanceRootDir,
+    "refresh-completions",
+    digest.slice(0, 2),
+    `${digest}.json`
+  );
+  const stat2 = await fs2.lstat(marker);
+  if (!stat2.isFile() || stat2.isSymbolicLink()) {
+    throw new Error("Canonical refresh completion has no producer authority marker");
+  }
+  const bytes = await fs2.readFile(marker);
+  const object = await fs2.readFile(store.objects.objectPath(completion));
+  if (addressBytes(bytes) !== completion || !bytes.equals(object)) {
+    throw new Error("Canonical refresh completion authority marker is corrupt");
   }
-  await conn.run(`
-    CREATE TABLE IF NOT EXISTS market.spot (
-      ticker VARCHAR NOT NULL,
-      date   VARCHAR NOT NULL,
-      time   VARCHAR NOT NULL,
-      open   DOUBLE,
-      high   DOUBLE,
-      low    DOUBLE,
-      close  DOUBLE,
-      bid    DOUBLE,
-      ask    DOUBLE,
-      PRIMARY KEY (ticker, date, time)
-    )
-  `);
-  await conn.run(`
-    CREATE TABLE IF NOT EXISTS market.enriched (
-      ticker                  VARCHAR NOT NULL,
-      date                    VARCHAR NOT NULL,
-      Prior_Close             DOUBLE,
-      Gap_Pct                 DOUBLE,
-      ATR_Pct                 DOUBLE,
-      RSI_14                  DOUBLE,
-      Price_vs_EMA21_Pct      DOUBLE,
-      Price_vs_SMA50_Pct      DOUBLE,
-      Realized_Vol_5D         DOUBLE,
-      Realized_Vol_20D        DOUBLE,
-      Return_5D               DOUBLE,
-      Return_20D              DOUBLE,
-      Intraday_Range_Pct      DOUBLE,
-      Intraday_Return_Pct     DOUBLE,
-      Close_Position_In_Range DOUBLE,
-      Gap_Filled              INTEGER,
-      Consecutive_Days        INTEGER,
-      Prev_Return_Pct         DOUBLE,
-      Prior_Range_vs_ATR      DOUBLE,
-      High_Time               DOUBLE,
-      Low_Time                DOUBLE,
-      High_Before_Low         INTEGER,
-      Reversal_Type           INTEGER,
-      Opening_Drive_Strength  DOUBLE,
-      Intraday_Realized_Vol   DOUBLE,
-      Day_of_Week             INTEGER,
-      Month                   INTEGER,
-      Is_Opex                 INTEGER,
-      ivr                     DOUBLE,
-      ivp                     DOUBLE,
-      PRIMARY KEY (ticker, date)
-    )
-  `);
-  await conn.run(`
-    CREATE TABLE IF NOT EXISTS market.enriched_context (
-      date                 VARCHAR NOT NULL,
-      Vol_Regime           INTEGER,
-      Term_Structure_State INTEGER,
-      Trend_Direction      VARCHAR,
-      VIX_Spike_Pct        DOUBLE,
-      VIX_Gap_Pct          DOUBLE,
-      PRIMARY KEY (date)
-    )
-  `);
 }
+var PartitionFilePublicationError = class extends Error {
+  targetPath;
+  file;
+  constructor(targetPath, file, cause) {
+    super(`Partition file installed without a complete projected commit: ${targetPath}`, { cause });
+    this.name = "PartitionFilePublicationError";
+    this.targetPath = targetPath;
+    this.file = file;
+  }
+};
 
-// src/db/parquet-writer.ts
-import * as fs from "fs/promises";
-import * as path3 from "path";
+// src/market/provenance/partition-commit-attempt.ts
+import { AsyncLocalStorage } from "async_hooks";
+var attempts = new AsyncLocalStorage();
+function compareCodePoints2(left, right) {
+  const leftPoints = Array.from(left, (character) => character.codePointAt(0));
+  const rightPoints = Array.from(right, (character) => character.codePointAt(0));
+  const length = Math.min(leftPoints.length, rightPoints.length);
+  for (let index = 0; index < length; index++) {
+    if (leftPoints[index] !== rightPoints[index]) return leftPoints[index] - rightPoints[index];
+  }
+  return leftPoints.length - rightPoints.length;
+}
+function commitTuple(commit) {
+  const partition = Object.entries(commit.receipt.partition).sort(([left], [right]) => compareCodePoints2(left, right)).flatMap(([key, value]) => [key, value]);
+  return [commit.receipt.dataset, ...partition, commit.address];
+}
+function compareTuple(left, right) {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const compared = compareCodePoints2(left[index], right[index]);
+    if (compared !== 0) return compared;
+  }
+  return left.length - right.length;
+}
+async function runPartitionCommitAttempt(options, operation) {
+  if (options.attemptId.trim().length === 0) {
+    throw new TypeError("Partition commit attemptId must not be empty");
+  }
+  const active = { ...options, receiptAddresses: [] };
+  const value = await attempts.run(active, operation);
+  const receipts = await Promise.all(
+    [...new Set(active.receiptAddresses)].map((address) => active.recorder.readCommit(address))
+  );
+  receipts.sort((left, right) => compareTuple(commitTuple(left), commitTuple(right)));
+  return {
+    attemptId: active.attemptId,
+    value,
+    receipts: Object.freeze(receipts)
+  };
+}
+function activePartitionCommitAttempt() {
+  return attempts.getStore();
+}
+function capturePartitionCommitReceipt(receipt) {
+  const active = attempts.getStore();
+  if (!active) return;
+  active.receiptAddresses.push(receipt.address);
+}
 
 // src/db/market-datasets.ts
-import * as path2 from "path";
+import * as path5 from "path";
 
 // src/db/data-root.ts
-import path from "path";
+import path4 from "path";
 var KEY = "__tradeblocks_data_root__";
 function resolveDbPath(dataRoot, kind) {
-  return path.join(dataRoot, "database", `${kind}.duckdb`);
+  return path4.join(dataRoot, "database", `${kind}.duckdb`);
 }
 function setDataRoot(dir) {
   globalThis[KEY] = dir;
@@ -242,23 +2003,26 @@ var PARTITIONED_DATASETS = {
   option_quote_minutes: "option_quote_minutes"
 };
 function resolveMarketDir(dataDir) {
-  return path2.join(getDataRoot(dataDir), "market");
+  return path5.join(getDataRoot(dataDir), "market");
 }
 function resolveCanonicalMarketFile(dataDir, dataset) {
-  return path2.join(resolveMarketDir(dataDir), SINGLE_FILE_DATASETS[dataset]);
+  return path5.join(resolveMarketDir(dataDir), SINGLE_FILE_DATASETS[dataset]);
 }
 function resolveCanonicalMarketPartitionDir(dataDir, dataset) {
-  return path2.join(resolveMarketDir(dataDir), PARTITIONED_DATASETS[dataset]);
+  return path5.join(resolveMarketDir(dataDir), PARTITIONED_DATASETS[dataset]);
 }
 function resolveCanonicalMarketPartitionPath(dataDir, dataset, date) {
-  return path2.join(resolveCanonicalMarketPartitionDir(dataDir, dataset), `date=${date}`);
+  return path5.join(resolveCanonicalMarketPartitionDir(dataDir, dataset), `date=${date}`);
 }
 function resolveCanonicalMarketPartitionFile(dataDir, dataset, date) {
-  return path2.join(resolveCanonicalMarketPartitionPath(dataDir, dataset, date), "data.parquet");
+  return path5.join(resolveCanonicalMarketPartitionPath(dataDir, dataset, date), "data.parquet");
 }
 function canonicalMarketTableName(dataset) {
   return `market.${dataset}`;
 }
+function provenanceOptions(dataset, partition, schemaRevision, relativePath, coverage, quality) {
+  return { dataset, partition, schemaRevision, relativePath, coverage, quality };
+}
 var DATASETS_V3 = {
   spot: { subdir: "spot", partitionKeys: ["ticker", "date"], filename: "data.parquet" },
   enriched: { subdir: "enriched", partitionKeys: ["ticker"], filename: "data.parquet" },
@@ -279,96 +2043,359 @@ var DATASETS_V3 = {
     filename: "data.parquet"
   }
 };
+var BOUNDED_PROVENANCE_DATASETS = MARKET_DATASETS;
+function assertCanonicalPartitionDate(value, helper) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    throw new TypeError(
+      `${helper}: date must be an ISO calendar date (YYYY-MM-DD): ${JSON.stringify(value)}`
+    );
+  }
+  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (!Number.isFinite(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== value) {
+    throw new TypeError(`${helper}: date is not a real calendar date: ${JSON.stringify(value)}`);
+  }
+}
 async function writeSpotPartition(conn, args) {
-  const def = DATASETS_V3.spot;
+  assertCanonicalPartitionDate(args.date, "writeSpotPartition");
+  const def = BOUNDED_PROVENANCE_DATASETS.spot;
   return writeParquetPartition(conn, {
-    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { ticker: args.ticker, date: args.date },
     // order matches def.partitionKeys
     selectQuery: args.selectQuery,
     compression: args.compression,
-    filename: def.filename
+    filename: def.filename,
+    provenance: provenanceOptions(
+      "spot",
+      { ticker: args.ticker, date: args.date },
+      def.schemaRevision,
+      path5.posix.join(def.subdir, `ticker=${args.ticker}`, `date=${args.date}`, def.filename),
+      { kind: "prepared-date-range", column: "date" },
+      args.quality
+    )
   });
 }
 async function writeChainPartition(conn, args) {
-  const def = DATASETS_V3.option_chain;
+  assertCanonicalPartitionDate(args.date, "writeChainPartition");
+  const def = BOUNDED_PROVENANCE_DATASETS.option_chain;
   return writeParquetPartition(conn, {
-    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: args.selectQuery,
     compression: args.compression,
-    filename: def.filename
+    filename: def.filename,
+    provenance: provenanceOptions(
+      "option_chain",
+      { underlying: args.underlying, date: args.date },
+      def.schemaRevision,
+      path5.posix.join(
+        def.subdir,
+        `underlying=${args.underlying}`,
+        `date=${args.date}`,
+        def.filename
+      ),
+      { kind: "prepared-date-range", column: "date" },
+      args.quality
+    )
   });
 }
 async function writeQuoteMinutesPartition(conn, args) {
-  const def = DATASETS_V3.option_quote_minutes;
+  assertCanonicalPartitionDate(args.date, "writeQuoteMinutesPartition");
+  const def = BOUNDED_PROVENANCE_DATASETS.option_quote_minutes;
   const sortedSelect = `SELECT * FROM (${args.selectQuery}) AS q ORDER BY q.ticker, q.time`;
   return writeParquetPartition(conn, {
-    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: sortedSelect,
     compression: args.compression,
-    filename: def.filename
+    filename: def.filename,
+    provenance: provenanceOptions(
+      "option_quote_minutes",
+      { underlying: args.underlying, date: args.date },
+      def.schemaRevision,
+      path5.posix.join(
+        def.subdir,
+        `underlying=${args.underlying}`,
+        `date=${args.date}`,
+        def.filename
+      ),
+      { kind: "prepared-date-range", column: "date" },
+      args.quality
+    )
   });
 }
 async function writeOiDailyPartition(conn, args) {
-  const def = DATASETS_V3.option_oi_daily;
+  assertCanonicalPartitionDate(args.date, "writeOiDailyPartition");
+  const def = BOUNDED_PROVENANCE_DATASETS.option_oi_daily;
   const sortedSelect = `SELECT * FROM (${args.selectQuery}) AS q ORDER BY q.ticker`;
   return writeParquetPartition(conn, {
-    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: sortedSelect,
     compression: args.compression,
-    filename: def.filename
+    filename: def.filename,
+    provenance: provenanceOptions(
+      "option_oi_daily",
+      { underlying: args.underlying, date: args.date },
+      def.schemaRevision,
+      path5.posix.join(
+        def.subdir,
+        `underlying=${args.underlying}`,
+        `date=${args.date}`,
+        def.filename
+      ),
+      { kind: "prepared-date-range", column: "date" },
+      args.quality
+    )
   });
 }
 async function writeEnrichedTickerFile(conn, args) {
   const def = DATASETS_V3.enriched;
   return writeParquetPartition(conn, {
-    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { ticker: args.ticker },
     selectQuery: args.selectQuery,
     compression: args.compression,
     filename: def.filename
   });
 }
+async function writeEnrichedTickerPartition(conn, args) {
+  assertCanonicalPartitionDate(args.date, "writeEnrichedTickerPartition");
+  const def = BOUNDED_PROVENANCE_DATASETS.enriched;
+  return writeParquetPartition(conn, {
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
+    partitions: { ticker: args.ticker, date: args.date },
+    selectQuery: args.selectQuery,
+    compression: args.compression,
+    filename: def.filename,
+    provenance: provenanceOptions(
+      "enriched",
+      { ticker: args.ticker, date: args.date },
+      def.schemaRevision,
+      path5.posix.join(def.subdir, `ticker=${args.ticker}`, `date=${args.date}`, def.filename),
+      { kind: "prepared-date-range", column: "date" },
+      args.quality
+    )
+  });
+}
 async function writeEnrichedContext(conn, args) {
   const def = DATASETS_V3.enriched_context;
-  const targetPath = path2.join(resolveMarketDir(args.dataDir), def.subdir, def.filename);
   return writeParquetAtomic(conn, {
-    targetPath,
+    targetPath: path5.join(resolveMarketDir(args.dataDir), def.subdir, def.filename),
     selectQuery: args.selectQuery,
     compression: args.compression
   });
 }
+async function writeEnrichedContextPartition(conn, args) {
+  assertCanonicalPartitionDate(args.date, "writeEnrichedContextPartition");
+  const completeness = await conn.runAndReadAll(
+    `SELECT date, Vol_Regime, Term_Structure_State, Trend_Direction,
+            VIX_Spike_Pct, VIX_Gap_Pct
+     FROM (${args.selectQuery}) AS bounded_enriched_context`
+  );
+  const rows = completeness.getRows();
+  if (rows.length !== 1) {
+    throw new Error(
+      `Enriched context partition ${args.date} must contain exactly one logical session row`
+    );
+  }
+  const [date, volRegime, termStructure, trendDirection, vixSpikePct, vixGapPct] = rows[0];
+  if (String(date) !== args.date) {
+    throw new Error(`Enriched context partition ${args.date} contains a different logical date`);
+  }
+  if (!Number.isInteger(volRegime) || Number(volRegime) < 1 || Number(volRegime) > 6 || !Number.isInteger(termStructure) || ![-1, 0, 1].includes(Number(termStructure)) || typeof trendDirection !== "string" || !["up", "down", "flat"].includes(trendDirection) || typeof vixSpikePct !== "number" || !Number.isFinite(vixSpikePct) || typeof vixGapPct !== "number" || !Number.isFinite(vixGapPct)) {
+    throw new Error(
+      `Enriched context partition ${args.date} is missing required VIX completeness fields`
+    );
+  }
+  const def = BOUNDED_PROVENANCE_DATASETS.enriched_context;
+  return writeParquetPartition(conn, {
+    baseDir: path5.join(resolveMarketDir(args.dataDir), def.subdir),
+    partitions: { date: args.date },
+    selectQuery: args.selectQuery,
+    compression: args.compression,
+    filename: def.filename,
+    provenance: provenanceOptions(
+      "enriched_context",
+      { date: args.date },
+      def.schemaRevision,
+      path5.posix.join(def.subdir, `date=${args.date}`, def.filename),
+      { kind: "prepared-date-range", column: "date" },
+      args.quality
+    )
+  });
+}
 
 // src/db/parquet-writer.ts
 function isParquetMode() {
   return process.env.TRADEBLOCKS_PARQUET === "true";
 }
+function captureWriteProvenance(provenance) {
+  if (!provenance) return void 0;
+  const captured = {
+    dataset: provenance.dataset,
+    partition: provenance.partition,
+    schemaRevision: provenance.schemaRevision,
+    relativePath: provenance.relativePath,
+    coverage: provenance.coverage,
+    ...provenance.quality === void 0 ? {} : { quality: provenance.quality }
+  };
+  return JSON.parse(canonicalJsonBytes(captured).toString("utf8"));
+}
+var ParquetProvenanceOrphanError = class extends Error {
+  targetPath;
+  file;
+  constructor(targetPath, file, cause) {
+    super(`Parquet data committed without provenance receipt: ${targetPath}`, { cause });
+    this.name = "ParquetProvenanceOrphanError";
+    this.targetPath = targetPath;
+    this.file = file;
+  }
+};
+var UnmanifestedParquetWriteError = class extends Error {
+  targetPath;
+  constructor(targetPath) {
+    super(`Active partition commit attempt refuses an unregistered Parquet write: ${targetPath}`);
+    this.name = "UnmanifestedParquetWriteError";
+    this.targetPath = targetPath;
+  }
+};
+async function exactFileFingerprint(filePath, rows) {
+  const hash = createHash3("sha256");
+  let bytes = 0;
+  for await (const chunk of createReadStream(filePath)) {
+    const buffer = chunk;
+    bytes += buffer.byteLength;
+    hash.update(buffer);
+  }
+  return { address: `sha256:${hash.digest("hex")}`, bytes, rows };
+}
+function escapeSqlLiteral2(value) {
+  return value.replaceAll("'", "''");
+}
+async function inspectPreparedParquet(conn, preparedPath, coverage) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(coverage.column)) {
+    throw new TypeError(`Unsafe provenance coverage column: ${JSON.stringify(coverage.column)}`);
+  }
+  const source = `read_parquet('${escapeSqlLiteral2(preparedPath)}', hive_partitioning=false)`;
+  const reader = await conn.runAndReadAll(
+    `SELECT COUNT(*)::BIGINT,
+            COUNT("${coverage.column}")::BIGINT,
+            MIN(CAST("${coverage.column}" AS VARCHAR)),
+            MAX(CAST("${coverage.column}" AS VARCHAR))
+       FROM ${source}`
+  );
+  const row = reader.getRows()[0];
+  const rowCount = Number(row[0]);
+  const coveredRows = Number(row[1]);
+  if (!Number.isSafeInteger(rowCount) || rowCount < 0 || !Number.isSafeInteger(coveredRows)) {
+    throw new Error("Prepared Parquet returned an invalid row count");
+  }
+  if (rowCount === 0) {
+    if (coveredRows !== 0 || row[2] != null || row[3] != null) {
+      throw new Error("Empty prepared Parquet returned inconsistent logical coverage");
+    }
+    return { rowCount, coverage: { kind: "empty" } };
+  }
+  if (coveredRows !== rowCount || row[2] == null || row[3] == null) {
+    throw new Error(
+      `Prepared Parquet contains NULL or incomplete logical coverage in ${coverage.column}`
+    );
+  }
+  return {
+    rowCount,
+    coverage: { kind: "date-range", from: String(row[2]), through: String(row[3]) }
+  };
+}
+async function syncFile(filePath) {
+  const handle = await fs3.open(filePath, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function syncDirectory(directory) {
+  const handle = await fs3.open(directory, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+function resolveQuality(rowCount, quality) {
+  if (!quality) {
+    throw new Error("Partition provenance requires explicit inputRows and droppedRows");
+  }
+  if ("kind" in quality) {
+    return { inputRows: rowCount, writtenRows: rowCount, droppedRows: 0 };
+  }
+  if (!Number.isSafeInteger(quality.inputRows) || !Number.isSafeInteger(quality.droppedRows) || quality.inputRows < 0 || quality.droppedRows < 0 || quality.inputRows !== rowCount + quality.droppedRows) {
+    throw new Error(
+      `Partition provenance quality must satisfy inputRows (${quality.inputRows}) = writtenRows (${rowCount}) + droppedRows (${quality.droppedRows})`
+    );
+  }
+  return {
+    inputRows: quality.inputRows,
+    writtenRows: rowCount,
+    droppedRows: quality.droppedRows
+  };
+}
 async function writeParquetAtomic(conn, opts) {
   const {
     targetPath,
     selectQuery,
     stagingName = `_staging_${Date.now()}`,
-    compression = "ZSTD"
+    compression = "ZSTD",
+    provenance: callerProvenance
   } = opts;
+  const provenance = captureWriteProvenance(callerProvenance);
+  const provenanceAttempt = activePartitionCommitAttempt();
+  if (provenanceAttempt && !provenance) throw new UnmanifestedParquetWriteError(targetPath);
   const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   try {
     await conn.run(`CREATE TEMP TABLE "${stagingName}" AS ${selectQuery}`);
-    await fs.mkdir(path3.dirname(targetPath), { recursive: true });
+    await fs3.mkdir(path6.dirname(targetPath), { recursive: true });
     await conn.run(
       `COPY "${stagingName}" TO '${tempPath}' (FORMAT PARQUET, COMPRESSION ${compression})`
     );
-    await fs.rename(tempPath, targetPath);
-    const reader = await conn.runAndReadAll(
-      `SELECT COUNT(*)::INTEGER AS cnt FROM "${stagingName}"`
+    const inspected = provenanceAttempt ? await inspectPreparedParquet(conn, tempPath, provenance.coverage) : void 0;
+    const rowCount = inspected ? inspected.rowCount : Number(
+      (await conn.runAndReadAll(`SELECT COUNT(*)::INTEGER AS cnt FROM "${stagingName}"`)).getRows()[0][0]
     );
-    const rowCount = Number(reader.getRows()[0][0]);
+    const logicalCoverage = inspected?.coverage;
+    const quality = provenanceAttempt ? resolveQuality(rowCount, provenance.quality) : void 0;
+    const fingerprint = provenanceAttempt ? await exactFileFingerprint(tempPath, rowCount) : void 0;
+    if (provenance && provenanceAttempt && fingerprint && logicalCoverage && quality) {
+      try {
+        const stored = await provenanceAttempt.recorder.publishFileCommit({
+          dataset: provenance.dataset,
+          partition: provenance.partition,
+          schemaRevision: provenance.schemaRevision,
+          relativePath: provenance.relativePath,
+          coverage: logicalCoverage,
+          quality,
+          file: fingerprint,
+          preparedPath: tempPath,
+          expectedTargetPath: targetPath
+        });
+        capturePartitionCommitReceipt(stored);
+        return { rowCount, provenance: stored };
+      } catch (error) {
+        if (error instanceof PartitionFilePublicationError) {
+          throw new ParquetProvenanceOrphanError(targetPath, fingerprint, error);
+        }
+        throw error;
+      }
+    }
+    await syncFile(tempPath);
+    await syncDirectory(path6.dirname(tempPath));
+    await fs3.rename(tempPath, targetPath);
+    await syncDirectory(path6.dirname(targetPath));
     return { rowCount };
   } catch (writeErr) {
     try {
-      await fs.unlink(tempPath);
+      await fs3.unlink(tempPath);
     } catch {
     }
     throw writeErr;
@@ -396,34 +2423,35 @@ async function writeParquetPartition(conn, opts) {
     }
   }
   const partitionSegments = Object.entries(partitions).map(([k, v]) => `${k}=${v}`);
-  const targetPath = path3.join(opts.baseDir, ...partitionSegments, filename);
+  const targetPath = path6.join(opts.baseDir, ...partitionSegments, filename);
   return writeParquetAtomic(conn, {
     targetPath,
     selectQuery: opts.selectQuery,
-    compression: opts.compression
+    compression: opts.compression,
+    provenance: opts.provenance
   });
 }
 
 // src/db/json-adapters.ts
-import * as fs3 from "fs/promises";
-import * as path5 from "path";
+import * as fs5 from "fs/promises";
+import * as path8 from "path";
 import { z } from "zod";
 
 // src/db/json-store.ts
-import * as fs2 from "fs/promises";
-import * as path4 from "path";
+import * as fs4 from "fs/promises";
+import * as path7 from "path";
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
 async function writeJsonFile(filePath, data) {
   const tmpPath = filePath + ".tmp";
-  await fs2.mkdir(path4.dirname(filePath), { recursive: true });
-  await fs2.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
-  await fs2.rename(tmpPath, filePath);
+  await fs4.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs4.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await fs4.rename(tmpPath, filePath);
 }
 async function readJsonFile(filePath) {
   try {
-    const content = await fs2.readFile(filePath, "utf-8");
+    const content = await fs4.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     if (isEnoent(err)) {
@@ -434,7 +2462,7 @@ async function readJsonFile(filePath) {
 }
 async function deleteJsonFile(filePath) {
   try {
-    await fs2.unlink(filePath);
+    await fs4.unlink(filePath);
     return true;
   } catch (err) {
     if (isEnoent(err)) {
@@ -445,8 +2473,8 @@ async function deleteJsonFile(filePath) {
 }
 async function listJsonFiles(dirPath, suffix = ".json") {
   try {
-    const entries = await fs2.readdir(dirPath, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && e.name.endsWith(suffix)).map((e) => path4.join(dirPath, e.name)).sort();
+    const entries = await fs4.readdir(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(suffix)).map((e) => path7.join(dirPath, e.name)).sort();
   } catch (err) {
     if (isEnoent(err)) {
       return [];
@@ -474,7 +2502,7 @@ function jsonToProfile(json) {
   };
 }
 function profilePath(blockId, strategyName, blocksDir) {
-  return path5.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
+  return path8.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
 }
 async function upsertProfileJson(profile, blocksDir) {
   const filePath = profilePath(profile.blockId, profile.strategyName, blocksDir);
@@ -496,7 +2524,7 @@ async function getProfileJson(blockId, strategyName, blocksDir) {
 }
 async function listProfilesJson(blocksDir, blockId) {
   if (blockId) {
-    const profileDir = path5.join(blocksDir, blockId, "profiles");
+    const profileDir = path8.join(blocksDir, blockId, "profiles");
     const files = await listJsonFiles(profileDir);
     const profiles2 = [];
     for (const file of files) {
@@ -508,7 +2536,7 @@ async function listProfilesJson(blocksDir, blockId) {
   const profiles = [];
   let entries;
   try {
-    entries = await fs3.readdir(blocksDir, { withFileTypes: true });
+    entries = await fs5.readdir(blocksDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -536,7 +2564,7 @@ function jsonToSyncMeta(json) {
   };
 }
 function syncMetaPath(blockId, blocksDir) {
-  return path5.join(blocksDir, blockId, ".sync-meta.json");
+  return path8.join(blocksDir, blockId, ".sync-meta.json");
 }
 async function getSyncMetadataJson(blockId, blocksDir) {
   const filePath = syncMetaPath(blockId, blocksDir);
@@ -554,7 +2582,7 @@ async function deleteSyncMetadataJson(blockId, blocksDir) {
 async function getAllSyncedBlockIdsJson(blocksDir) {
   let entries;
   try {
-    entries = await fs3.readdir(blocksDir, { withFileTypes: true });
+    entries = await fs5.readdir(blocksDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -563,7 +2591,7 @@ async function getAllSyncedBlockIdsJson(blocksDir) {
     if (!entry.isDirectory()) continue;
     const metaPath = syncMetaPath(entry.name, blocksDir);
     try {
-      await fs3.access(metaPath);
+      await fs5.access(metaPath);
       ids.push(entry.name);
     } catch {
     }
@@ -574,7 +2602,7 @@ function marketMetaKey(source, ticker, targetTable) {
   return `${source}|${ticker}|${targetTable}`;
 }
 function marketMetaFilePath(dataDir) {
-  return path5.join(getDataRoot(dataDir), "market-meta", "sync-metadata.json");
+  return path8.join(getDataRoot(dataDir), "market-meta", "sync-metadata.json");
 }
 async function getMarketImportMetadataJson(source, ticker, targetTable, dataDir) {
   const filePath = marketMetaFilePath(dataDir);
@@ -602,7 +2630,7 @@ function flatLogKey(entry) {
   return `${entry.date}|${entry.asset_class}|${entry.underlying}`;
 }
 function flatLogFilePath(dataDir) {
-  return path5.join(getDataRoot(dataDir), "market-meta", "flat-import-log.json");
+  return path8.join(getDataRoot(dataDir), "market-meta", "flat-import-log.json");
 }
 async function getFlatImportLogJson(assetClass, underlying, from, to, dataDir) {
   const filePath = flatLogFilePath(dataDir);
@@ -640,7 +2668,7 @@ var EnrichmentWatermarksSchema = z.object({
   watermarks: z.record(z.string().regex(/^[A-Z0-9._-]+$/), TickerEntrySchema)
 });
 function watermarksFilePath(dataDir) {
-  return path5.join(getDataRoot(dataDir), "market-meta", "enrichment-watermarks.json");
+  return path8.join(getDataRoot(dataDir), "market-meta", "enrichment-watermarks.json");
 }
 async function loadEnrichmentWatermarks(dataDir) {
   const raw = await readJsonFile(watermarksFilePath(dataDir));
@@ -947,121 +2975,19 @@ async function deleteProfile(conn, blockId, strategyName, baseDir) {
 
 // src/db/market-views.ts
 import { existsSync, readdirSync } from "fs";
-import * as path6 from "path";
-
-// src/utils/quote-parquet-projection.ts
-var describeCache = /* @__PURE__ */ new Map();
-function escapeSqlLiteral(value) {
-  return value.replace(/'/g, "''");
-}
-function readParquetGlobSql(glob) {
-  return `read_parquet('${escapeSqlLiteral(glob)}', hive_partitioning=true, union_by_name=true)`;
-}
-function readParquetFilesSql(files) {
-  if (files.length === 0) {
-    throw new Error("readParquetFilesSql: files must not be empty");
-  }
-  const fileList = files.map((filePath) => `'${escapeSqlLiteral(filePath)}'`).join(", ");
-  return `read_parquet([${fileList}], hive_partitioning=true, union_by_name=true)`;
-}
-async function describeReadParquetColumns(conn, readParquetSql) {
-  let pending = describeCache.get(readParquetSql);
-  if (!pending) {
-    pending = (async () => {
-      const reader = await conn.runAndReadAll(`DESCRIBE SELECT * FROM ${readParquetSql}`);
-      return new Set(reader.getRows().map((row) => String(row[0]).toLowerCase()));
-    })();
-    describeCache.set(readParquetSql, pending);
-  }
-  return pending;
-}
-async function describeQueryColumns(conn, querySql) {
-  const reader = await conn.runAndReadAll(`DESCRIBE ${querySql}`);
-  return new Set(reader.getRows().map((row) => String(row[0]).toLowerCase()));
-}
-function hasColumn2(columns, name) {
-  return columns.has(name.toLowerCase());
-}
-function quoteParquetColumnExpr(columns, alias, name, fallbackType) {
-  return hasColumn2(columns, name) ? `${alias}.${name}` : `NULL::${fallbackType}`;
-}
-function quoteParquetMidExpr(columns, alias) {
-  return hasColumn2(columns, "mid") ? `${alias}.mid` : `((CAST(${alias}.bid AS DOUBLE) + CAST(${alias}.ask AS DOUBLE)) / 2)`;
-}
-var ALL_GREEKS = ["delta", "gamma", "theta", "vega", "iv"];
-function quoteParquetGreekProjection(columns, alias = "q", needed = ALL_GREEKS) {
-  const wantSet = new Set(needed);
-  const projectGreek = (name) => wantSet.has(name) ? `${quoteParquetColumnExpr(columns, alias, name, "DOUBLE")} AS ${name}` : `NULL::DOUBLE AS ${name}`;
-  return [
-    projectGreek("delta"),
-    projectGreek("gamma"),
-    projectGreek("theta"),
-    projectGreek("vega"),
-    projectGreek("iv"),
-    `${quoteParquetColumnExpr(columns, alias, "greeks_source", "VARCHAR")} AS greeks_source`,
-    `${quoteParquetColumnExpr(columns, alias, "greeks_revision", "INTEGER")} AS greeks_revision`,
-    `${quoteParquetColumnExpr(columns, alias, "rate_type", "VARCHAR")} AS rate_type`,
-    `${quoteParquetColumnExpr(columns, alias, "rate_value", "DOUBLE")} AS rate_value`,
-    `${quoteParquetColumnExpr(columns, alias, "gamma_source", "VARCHAR")} AS gamma_source`
-  ].join(",\n              ");
-}
-function quoteParquetGreekWriteProjection(columns, alias = "q") {
-  const castReal = (name) => hasColumn2(columns, name) ? `CAST(${alias}.${name} AS REAL)` : `NULL::REAL`;
-  return [
-    `${castReal("delta")} AS delta`,
-    `${castReal("gamma")} AS gamma`,
-    `${castReal("theta")} AS theta`,
-    `${castReal("vega")} AS vega`,
-    `${castReal("iv")} AS iv`,
-    `${quoteParquetColumnExpr(columns, alias, "greeks_source", "VARCHAR")} AS greeks_source`,
-    `${quoteParquetColumnExpr(columns, alias, "greeks_revision", "INTEGER")} AS greeks_revision`,
-    `${quoteParquetColumnExpr(columns, alias, "rate_type", "VARCHAR")} AS rate_type`,
-    `${quoteParquetColumnExpr(columns, alias, "rate_value", "DOUBLE")} AS rate_value`,
-    `${quoteParquetColumnExpr(columns, alias, "gamma_source", "VARCHAR")} AS gamma_source`
-  ].join(",\n              ");
-}
-function quoteParquetCanonicalProjection(columns, alias = "q") {
-  return [
-    `${quoteParquetColumnExpr(columns, alias, "underlying", "VARCHAR")} AS underlying`,
-    `${quoteParquetColumnExpr(columns, alias, "date", "VARCHAR")} AS date`,
-    `${quoteParquetColumnExpr(columns, alias, "ticker", "VARCHAR")} AS ticker`,
-    `${quoteParquetColumnExpr(columns, alias, "time", "VARCHAR")} AS time`,
-    `${quoteParquetColumnExpr(columns, alias, "bid", "DOUBLE")} AS bid`,
-    `${quoteParquetColumnExpr(columns, alias, "ask", "DOUBLE")} AS ask`,
-    `${quoteParquetMidExpr(columns, alias)} AS mid`,
-    `${quoteParquetColumnExpr(columns, alias, "last_updated_ns", "BIGINT")} AS last_updated_ns`,
-    `${quoteParquetColumnExpr(columns, alias, "source", "VARCHAR")} AS source`,
-    quoteParquetGreekProjection(columns, alias)
-  ].join(",\n              ");
-}
-function quoteParquetCanonicalWriteProjection(columns, alias = "q") {
-  return [
-    `${quoteParquetColumnExpr(columns, alias, "underlying", "VARCHAR")} AS underlying`,
-    `${quoteParquetColumnExpr(columns, alias, "date", "VARCHAR")} AS date`,
-    `${quoteParquetColumnExpr(columns, alias, "ticker", "VARCHAR")} AS ticker`,
-    `${quoteParquetColumnExpr(columns, alias, "time", "VARCHAR")} AS time`,
-    `${quoteParquetColumnExpr(columns, alias, "bid", "DOUBLE")} AS bid`,
-    `${quoteParquetColumnExpr(columns, alias, "ask", "DOUBLE")} AS ask`,
-    `${quoteParquetMidExpr(columns, alias)} AS mid`,
-    `${quoteParquetColumnExpr(columns, alias, "last_updated_ns", "BIGINT")} AS last_updated_ns`,
-    `${quoteParquetColumnExpr(columns, alias, "source", "VARCHAR")} AS source`,
-    quoteParquetGreekWriteProjection(columns, alias)
-  ].join(",\n              ");
-}
-
-// src/db/market-views.ts
+import * as path9 from "path";
 function hasParquetPartitions(dir, partitionKey = "date") {
   if (!existsSync(dir)) return false;
   try {
     const prefix = `${partitionKey}=`;
     return readdirSync(dir).some((entry) => {
       if (!entry.startsWith(prefix)) return false;
-      const partDir = path6.join(dir, entry);
+      const partDir = path9.join(dir, entry);
       try {
         const entries = readdirSync(partDir);
         for (const sub of entries) {
           if (sub.endsWith(".parquet")) return true;
-          const nested = path6.join(partDir, sub);
+          const nested = path9.join(partDir, sub);
           try {
             if (readdirSync(nested).some((f) => f.endsWith(".parquet"))) return true;
           } catch {
@@ -1081,14 +3007,29 @@ function hasEnrichedTickerFiles(dir) {
   try {
     return readdirSync(dir).some((entry) => {
       if (!entry.startsWith("ticker=")) return false;
-      return existsSync(path6.join(dir, entry, "data.parquet"));
+      const tickerDir = path9.join(dir, entry);
+      try {
+        return readdirSync(tickerDir).some(
+          (dateEntry) => dateEntry.startsWith("date=") && existsSync(path9.join(tickerDir, dateEntry, "data.parquet"))
+        );
+      } catch {
+        return false;
+      }
     });
   } catch {
     return false;
   }
 }
 function hasEnrichedContextFile(dir) {
-  return existsSync(path6.join(dir, "context", "data.parquet"));
+  const contextDir = path9.join(dir, "context");
+  if (!existsSync(contextDir)) return false;
+  try {
+    return readdirSync(contextDir).some(
+      (entry) => entry.startsWith("date=") && existsSync(path9.join(contextDir, entry, "data.parquet"))
+    );
+  } catch {
+    return false;
+  }
 }
 async function createMarketParquetViews(conn, dataDir) {
   const viewsCreated = [];
@@ -1169,7 +3110,7 @@ async function createMarketParquetViews(conn, dataDir) {
     await conn.run("DROP TABLE IF EXISTS market.option_delta_index");
   } catch {
   }
-  const spotDir = path6.join(resolveMarketDir(dataDir), "spot");
+  const spotDir = path9.join(resolveMarketDir(dataDir), "spot");
   if (hasParquetPartitions(spotDir, "ticker")) {
     try {
       await conn.run("DROP VIEW  IF EXISTS market.spot");
@@ -1191,7 +3132,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     tablesKept.push("spot");
   }
-  const enrichedDir = path6.join(resolveMarketDir(dataDir), "enriched");
+  const enrichedDir = path9.join(resolveMarketDir(dataDir), "enriched");
   if (hasEnrichedTickerFiles(enrichedDir)) {
     try {
       await conn.run("DROP VIEW  IF EXISTS market.enriched");
@@ -1203,7 +3144,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     await conn.run(
       `CREATE OR REPLACE VIEW market.enriched AS
-       SELECT * FROM read_parquet('${enrichedDir}/ticker=*/data.parquet', hive_partitioning=true)`
+       SELECT * FROM read_parquet('${enrichedDir}/ticker=*/date=*/data.parquet', hive_partitioning=true)`
     );
     viewsCreated.push("enriched");
   } else {
@@ -1224,7 +3165,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     await conn.run(
       `CREATE OR REPLACE VIEW market.enriched_context AS
-       SELECT * FROM read_parquet('${path6.join(enrichedDir, "context", "data.parquet")}')`
+       SELECT * FROM read_parquet('${path9.join(enrichedDir, "context", "date=*", "data.parquet")}', hive_partitioning=true)`
     );
     viewsCreated.push("enriched_context");
   } else {
@@ -1289,7 +3230,7 @@ async function createMarketParquetViews(conn, dataDir) {
 }
 
 // src/db/json-migration.ts
-import * as path7 from "path";
+import * as path10 from "path";
 function toDate2(value) {
   if (value instanceof Date) return value;
   if (typeof value === "object" && value !== null && "micros" in value) {
@@ -1366,7 +3307,7 @@ async function migrateProfiles(conn, blocksDir) {
       createdAt: createdAt.toISOString(),
       updatedAt: updatedAt.toISOString()
     };
-    const filePath = path7.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
+    const filePath = path10.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
     await writeJsonFile(filePath, profileJson);
   }
   return rows.length;
@@ -1399,7 +3340,7 @@ async function migrateSyncMetadata(conn, blocksDir) {
   return rows.length;
 }
 async function migrateMarketImportMetadata(conn, dataDir) {
-  const existingFile = await readJsonFile(path7.join(dataDir, "market-meta", "sync-metadata.json"));
+  const existingFile = await readJsonFile(path10.join(dataDir, "market-meta", "sync-metadata.json"));
   if (existingFile !== null) return 0;
   let rows;
   try {
@@ -1426,7 +3367,7 @@ async function migrateMarketImportMetadata(conn, dataDir) {
 }
 async function migrateFlatImportLog(conn, dataDir) {
   const existingFile = await readJsonFile(
-    path7.join(dataDir, "market-meta", "flat-import-log.json")
+    path10.join(dataDir, "market-meta", "flat-import-log.json")
   );
   if (existingFile !== null) return 0;
   let rows;
@@ -1557,7 +3498,7 @@ async function waitForProcessExit(pid, timeoutMs) {
     if (!isProcessAlive(pid)) {
       return true;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 100));
+    await new Promise((resolve3) => setTimeout(resolve3, 100));
   }
   return !isProcessAlive(pid);
 }
@@ -1571,7 +3512,7 @@ async function tryRecoverLockByTerminatingStaleProcess(errorMessage, dbPath, for
     return false;
   }
   const normalizedDbPath = dbPath.replace(/\\/g, "/");
-  const normalizedDbDir = path8.dirname(normalizedDbPath);
+  const normalizedDbDir = path11.dirname(normalizedDbPath);
   const isTradeblocksProcess = command.includes("tradeblocks-mcp") || command.includes("/mcp-server/server/index.js") || command.includes("packages/mcp-server/server/index.js") || command.includes("\\mcp-server\\server\\index.js") || command.includes("packages\\mcp-server\\server\\index.js");
   const normalizedCommand = command.replace(/\\/g, "/");
   const targetsSameDb = normalizedCommand.includes(normalizedDbPath) || normalizedCommand.includes(normalizedDbDir);
@@ -1605,16 +3546,16 @@ function resolveMarketDbPath(dataDir) {
   const args = process.argv;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--market-db" && args[i + 1]) {
-      return path8.resolve(args[i + 1]);
+      return path11.resolve(args[i + 1]);
     }
   }
   if (process.env.MARKET_DB_PATH) {
-    return path8.resolve(process.env.MARKET_DB_PATH);
+    return path11.resolve(process.env.MARKET_DB_PATH);
   }
-  return path8.join(dataDir, "market.duckdb");
+  return path11.join(dataDir, "market.duckdb");
 }
 async function attachMarketDb(conn, marketDbPath, mode) {
-  await fs4.mkdir(path8.dirname(marketDbPath), { recursive: true });
+  await fs6.mkdir(path11.dirname(marketDbPath), { recursive: true });
   const readOnlyClause = mode === "read_only" ? " (READ_ONLY)" : "";
   const escapedPath = marketDbPath.replace(/'/g, "''");
   try {
@@ -1624,11 +3565,11 @@ async function attachMarketDb(conn, marketDbPath, mode) {
     if (msg.includes("corrupt") || msg.includes("Invalid") || msg.includes("cannot open")) {
       console.error(`market.duckdb appears corrupted at ${marketDbPath}. Recreating.`);
       try {
-        await fs4.unlink(marketDbPath);
+        await fs6.unlink(marketDbPath);
       } catch {
       }
       try {
-        await fs4.unlink(marketDbPath + ".wal");
+        await fs6.unlink(marketDbPath + ".wal");
       } catch {
       }
       await conn.run(`ATTACH '${escapedPath}' AS market${readOnlyClause}`);
@@ -1661,12 +3602,12 @@ async function openReadWriteConnection(dbPath, threads, memoryLimit) {
   await ensureReportingDataTable(connection);
   await ensureMutableMarketTables(connection);
   await ensureProfilesSchema(connection);
-  const dataDir = path8.dirname(dbPath);
+  const dataDir = path11.dirname(dbPath);
   const dataRoot = getDataRoot(dataDir);
   await createMarketParquetViews(connection, dataRoot);
   await ensureMarketDataTables(connection);
   try {
-    const blocksDir = (await import("./sync-3UBC37VW.js")).getBlocksDir(dataRoot);
+    const blocksDir = (await import("./sync-AWI764HE.js")).getBlocksDir(dataRoot);
     await migrateMetadataToJson(connection, dataRoot, blocksDir);
   } catch (err) {
     console.warn(
@@ -1712,7 +3653,7 @@ async function getConnection(dataDir) {
   if (connection) {
     return connection;
   }
-  const dbPath = path8.join(dataDir, "analytics.duckdb");
+  const dbPath = path11.join(dataDir, "analytics.duckdb");
   const threads = process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   storedDbPath = dbPath;
@@ -1789,7 +3730,7 @@ async function closeConnection() {
 async function upgradeToReadWrite(dataDir, options) {
   if (connectionMode === "read_write" && connection) return connection;
   await closeConnection();
-  const dbPath = storedDbPath || path8.join(dataDir, "analytics.duckdb");
+  const dbPath = storedDbPath || path11.join(dataDir, "analytics.duckdb");
   const threads = storedThreads || process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = storedMemoryLimit || process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   if (!storedMarketDbPath) {
@@ -1861,11 +3802,57 @@ async function openMarketOnlyConnection(baseDir) {
   };
   return { conn, marketDbPath, close };
 }
-async function openMarketParquetConnection(baseDir) {
+var DUCKDB_MEMORY_LIMIT_PATTERN = /^\d+(\.\d+)?(KB|MB|GB|TB|KiB|MiB|GiB|TiB)$/i;
+function validateMemoryLimit(value) {
+  const trimmed = value.trim();
+  if (!DUCKDB_MEMORY_LIMIT_PATTERN.test(trimmed)) {
+    throw new Error(
+      `Invalid DuckDB memory_limit ${JSON.stringify(value)}. Expected a number followed by a unit, e.g. "4GB", "512MB", or "8GiB" (units: KB, MB, GB, TB, KiB, MiB, GiB, TiB).`
+    );
+  }
+  return trimmed;
+}
+function validateThreads(value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(
+      `Invalid DuckDB threads ${JSON.stringify(value)}. Expected a positive integer.`
+    );
+  }
+  return value;
+}
+function resolveResourceBounds(options) {
+  const resolved = {};
+  const memoryLimitRaw = options?.memoryLimit ?? envValue("TRADEBLOCKS_DUCKDB_MEMORY_LIMIT");
+  if (memoryLimitRaw !== void 0) {
+    resolved.memoryLimit = validateMemoryLimit(memoryLimitRaw);
+  }
+  const threadsEnv = envValue("TRADEBLOCKS_DUCKDB_THREADS");
+  const threadsRaw = options?.threads ?? (threadsEnv !== void 0 ? Number(threadsEnv) : void 0);
+  if (threadsRaw !== void 0) {
+    resolved.threads = validateThreads(threadsRaw);
+  }
+  return resolved;
+}
+function envValue(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  return raw;
+}
+async function applyResourceBounds(conn, bounds) {
+  if (bounds.memoryLimit !== void 0) {
+    await conn.run(`SET memory_limit='${bounds.memoryLimit}'`);
+  }
+  if (bounds.threads !== void 0) {
+    await conn.run(`SET threads=${bounds.threads}`);
+  }
+}
+async function openMarketParquetConnection(baseDir, options) {
+  const bounds = resolveResourceBounds(options);
   const memoryInstance = await DuckDBInstance.create(":memory:", {
     enable_external_access: "true"
   });
   const conn = await memoryInstance.connect();
+  await applyResourceBounds(conn, bounds);
   await conn.run("CREATE SCHEMA IF NOT EXISTS market");
   const dataRoot = getDataRoot(baseDir);
   await createMarketParquetViews(conn, dataRoot);
@@ -1884,12 +3871,12 @@ async function openMarketParquetConnection(baseDir) {
   };
   return { conn, dataRoot, close };
 }
-function openMarketReadOnlyConnection(baseDir) {
-  return openMarketParquetConnection(baseDir);
+function openMarketReadOnlyConnection(baseDir, options) {
+  return openMarketParquetConnection(baseDir, options);
 }
 async function getReadOnlyConnection(dataDir) {
   if (connection) return connection;
-  const dbPath = path8.join(dataDir, "analytics.duckdb");
+  const dbPath = path11.join(dataDir, "analytics.duckdb");
   const threads = process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   storedDbPath = dbPath;
@@ -1915,14 +3902,14 @@ function getCurrentConnection() {
 }
 
 // src/sync/block-sync.ts
-import * as fs8 from "fs/promises";
-import * as path11 from "path";
+import * as fs10 from "fs/promises";
+import * as path14 from "path";
 
 // src/sync/hasher.ts
 import * as crypto from "crypto";
-import * as fs5 from "fs/promises";
+import * as fs7 from "fs/promises";
 async function hashFileContent(filePath) {
-  const buffer = await fs5.readFile(filePath);
+  const buffer = await fs7.readFile(filePath);
   return crypto.createHash("sha256").update(buffer).digest("hex");
 }
 
@@ -2072,12 +4059,12 @@ function marketTickerDateKey(ticker, date) {
 }
 
 // src/utils/block-loader.ts
-import * as fs7 from "fs/promises";
-import * as path10 from "path";
+import * as fs9 from "fs/promises";
+import * as path13 from "path";
 
 // src/utils/csv-discovery.ts
-import * as fs6 from "fs/promises";
-import * as path9 from "path";
+import * as fs8 from "fs/promises";
+import * as path12 from "path";
 function parseCSVLine(line) {
   const result = [];
   let current = "";
@@ -2102,7 +4089,7 @@ function parseCSVLine(line) {
   return result;
 }
 async function readCsvHeaders(filePath) {
-  const content = await fs6.readFile(filePath, "utf-8");
+  const content = await fs8.readFile(filePath, "utf-8");
   const firstLine = content.replace(/^\uFEFF/, "").split("\n")[0] || "";
   return parseCSVLine(firstLine).map((h) => h.toLowerCase().trim());
 }
@@ -2178,7 +4165,7 @@ async function discoverCsvFiles(folderPath) {
   const mappings = {};
   const unrecognized = [];
   try {
-    const entries = await fs6.readdir(folderPath, { withFileTypes: true });
+    const entries = await fs8.readdir(folderPath, { withFileTypes: true });
     const csvFiles = entries.filter((e) => e.isFile() && e.name.toLowerCase().endsWith(".csv")).map((e) => e.name);
     if (csvFiles.includes("tradelog.csv")) {
       mappings.tradelog = "tradelog.csv";
@@ -2202,7 +4189,7 @@ async function discoverCsvFiles(folderPath) {
       if (csvFile === "tradelog.csv" || csvFile === "dailylog.csv" || csvFile === "reportinglog.csv" || csvFile === mappings.reportinglog) {
         continue;
       }
-      const csvPath = path9.join(folderPath, csvFile);
+      const csvPath = path12.join(folderPath, csvFile);
       const detectedType = await detectCsvType(csvPath);
       if (detectedType) {
         if (detectedType === "tradelog" && !mappings.tradelog) {
@@ -2398,8 +4385,8 @@ function convertToDailyLogEntry(raw, blockId) {
   }
 }
 async function loadTrades(blockPath, filename = "tradelog.csv", blockId) {
-  const tradelogPath = path10.join(blockPath, filename);
-  const content = await fs7.readFile(tradelogPath, "utf-8");
+  const tradelogPath = path13.join(blockPath, filename);
+  const content = await fs9.readFile(tradelogPath, "utf-8");
   const records = parseCSV(content);
   const trades = [];
   for (const record of records) {
@@ -2416,10 +4403,10 @@ async function loadTrades(blockPath, filename = "tradelog.csv", blockId) {
   return trades;
 }
 async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
-  const dailylogPath = path10.join(blockPath, filename);
+  const dailylogPath = path13.join(blockPath, filename);
   try {
-    await fs7.access(dailylogPath);
-    const content = await fs7.readFile(dailylogPath, "utf-8");
+    await fs9.access(dailylogPath);
+    const content = await fs9.readFile(dailylogPath, "utf-8");
     const records = parseCSV(content);
     const entries = [];
     for (const record of records) {
@@ -2436,12 +4423,12 @@ async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
 }
 async function loadBlock(baseDir, blockId) {
   const blocksDir = resolveBlocksBaseDir(baseDir);
-  const blockPath = path10.join(blocksDir, blockId);
+  const blockPath = path13.join(blocksDir, blockId);
   const { mappings } = await discoverCsvFiles(blockPath);
   const tradelogFilename = mappings.tradelog || "tradelog.csv";
-  const tradelogPath = path10.join(blockPath, tradelogFilename);
+  const tradelogPath = path13.join(blockPath, tradelogFilename);
   try {
-    await fs7.access(tradelogPath);
+    await fs9.access(tradelogPath);
   } catch {
     throw new Error(`Block not found or missing tradelog: ${blockId}`);
   }
@@ -2542,7 +4529,7 @@ async function listBlocks(baseDir) {
     }
     const syncMeta = /* @__PURE__ */ new Map();
     if (isParquetMode()) {
-      const metaEntries = await fs7.readdir(blocksDir, { withFileTypes: true });
+      const metaEntries = await fs9.readdir(blocksDir, { withFileTypes: true });
       for (const entry of metaEntries) {
         if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
         const meta = await getSyncMetadataJson(entry.name, blocksDir);
@@ -2565,7 +4552,7 @@ async function listBlocks(baseDir) {
         });
       }
     }
-    const entries = await fs7.readdir(blocksDir, { withFileTypes: true });
+    const entries = await fs9.readdir(blocksDir, { withFileTypes: true });
     const blockFolders = /* @__PURE__ */ new Set();
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
@@ -2609,7 +4596,7 @@ async function listBlocks(baseDir) {
         }
         blocks.push(info);
       } else if (!stats) {
-        const blockPath = path10.join(blocksDir, blockId);
+        const blockPath = path13.join(blocksDir, blockId);
         try {
           const { mappings } = await discoverCsvFiles(blockPath);
           if (mappings.tradelog) {
@@ -2677,16 +4664,16 @@ function convertToReportingTrade(raw) {
 }
 async function loadReportingLog(baseDir, blockId) {
   const blocksDir = resolveBlocksBaseDir(baseDir);
-  const blockPath = path10.join(blocksDir, blockId);
+  const blockPath = path13.join(blocksDir, blockId);
   const { mappings } = await discoverCsvFiles(blockPath);
   const filename = mappings.reportinglog || "reportinglog.csv";
-  const reportingLogPath = path10.join(blockPath, filename);
+  const reportingLogPath = path13.join(blockPath, filename);
   try {
-    await fs7.access(reportingLogPath);
+    await fs9.access(reportingLogPath);
   } catch {
     throw new Error(`reportinglog.csv not found in block: ${blockId}`);
   }
-  const content = await fs7.readFile(reportingLogPath, "utf-8");
+  const content = await fs9.readFile(reportingLogPath, "utf-8");
   const records = parseCSV(content);
   const trades = [];
   for (const record of records) {
@@ -2756,11 +4743,11 @@ async function importCsv(baseDir, options) {
   let { csvType = "tradelog" } = options;
   const blocksDir = resolveBlocksBaseDir(baseDir);
   try {
-    await fs7.access(csvPath);
+    await fs9.access(csvPath);
   } catch {
     throw new Error(`CSV file not found: ${csvPath}`);
   }
-  const content = await fs7.readFile(csvPath, "utf-8");
+  const content = await fs9.readFile(csvPath, "utf-8");
   const records = parseCSV(content);
   if (csvType === "tradelog" && records.length > 0) {
     const headers = Object.keys(records[0]);
@@ -2777,9 +4764,9 @@ async function importCsv(baseDir, options) {
   if (!blockId) {
     throw new Error("Could not derive a valid block ID from the filename or provided name");
   }
-  const blockPath = path10.join(blocksDir, blockId);
+  const blockPath = path13.join(blocksDir, blockId);
   try {
-    await fs7.access(blockPath);
+    await fs9.access(blockPath);
     throw new Error(
       `Block "${blockId}" already exists. Use a different blockName or delete the existing block first.`
     );
@@ -2788,10 +4775,10 @@ async function importCsv(baseDir, options) {
       throw error;
     }
   }
-  await fs7.mkdir(blockPath, { recursive: true });
+  await fs9.mkdir(blockPath, { recursive: true });
   const targetFilename = csvType === "tradelog" ? "tradelog.csv" : csvType === "dailylog" ? "dailylog.csv" : "reportinglog.csv";
-  const targetPath = path10.join(blockPath, targetFilename);
-  await fs7.copyFile(csvPath, targetPath);
+  const targetPath = path13.join(blockPath, targetFilename);
+  await fs9.copyFile(csvPath, targetPath);
   let dateRange = {
     start: null,
     end: null
@@ -3036,7 +5023,7 @@ function versionedHash(hash) {
   return `${hash}:${PARSE_VERSION}`;
 }
 async function syncBlockInternal(conn, blockId, blockPath) {
-  const blocksDir = path11.dirname(blockPath);
+  const blocksDir = path14.dirname(blockPath);
   try {
     const existingMetadata = await getSyncMetadata(conn, blockId, blocksDir);
     const tradelogFilename = await findTradelogFile(blockPath);
@@ -3060,12 +5047,12 @@ async function syncBlockInternal(conn, blockId, blockPath) {
         error: "No tradelog CSV found in block"
       };
     }
-    const tradelogPath = path11.join(blockPath, tradelogFilename);
+    const tradelogPath = path14.join(blockPath, tradelogFilename);
     const tradelogHash = versionedHash(await hashFileContent(tradelogPath));
     if (existingMetadata && existingMetadata.tradelog_hash === tradelogHash) {
       const optionalLogs = await findOptionalLogFiles(blockPath);
       if (optionalLogs.reportinglog) {
-        const reportinglogPath = path11.join(blockPath, optionalLogs.reportinglog);
+        const reportinglogPath = path14.join(blockPath, optionalLogs.reportinglog);
         const reportinglogHash = versionedHash(await hashFileContent(reportinglogPath));
         if (existingMetadata.reportinglog_hash !== reportinglogHash) {
         } else {
@@ -3081,7 +5068,7 @@ async function syncBlockInternal(conn, blockId, blockPath) {
     await conn.run("BEGIN TRANSACTION");
     try {
       await conn.run("DELETE FROM trades.trade_data WHERE block_id = $1", [blockId]);
-      const csvContent = await fs8.readFile(tradelogPath, "utf-8");
+      const csvContent = await fs10.readFile(tradelogPath, "utf-8");
       const records = parseCSV2(csvContent);
       const batchSize = 500;
       for (let i = 0; i < records.length; i += batchSize) {
@@ -3093,7 +5080,7 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       if (optionalLogs.dailylog) {
         try {
           dailylogHash = versionedHash(
-            await hashFileContent(path11.join(blockPath, optionalLogs.dailylog))
+            await hashFileContent(path14.join(blockPath, optionalLogs.dailylog))
           );
         } catch {
         }
@@ -3101,15 +5088,15 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       if (optionalLogs.reportinglog) {
         try {
           reportinglogHash = versionedHash(
-            await hashFileContent(path11.join(blockPath, optionalLogs.reportinglog))
+            await hashFileContent(path14.join(blockPath, optionalLogs.reportinglog))
           );
         } catch {
         }
       }
       await conn.run("DELETE FROM trades.reporting_data WHERE block_id = $1", [blockId]);
       if (optionalLogs.reportinglog && reportinglogHash) {
-        const reportingPath = path11.join(blockPath, optionalLogs.reportinglog);
-        const reportingContent = await fs8.readFile(reportingPath, "utf-8");
+        const reportingPath = path14.join(blockPath, optionalLogs.reportinglog);
+        const reportingContent = await fs10.readFile(reportingPath, "utf-8");
         const reportingRecords = parseCSV2(reportingContent);
         const reportingTrades = [];
         const reportingTickers = [];
@@ -3177,7 +5164,7 @@ async function detectBlockChanges(conn, baseDir) {
   const toSync = [];
   const toDelete = [];
   const syncedBlockIds = new Set(await getAllSyncedBlockIds(conn, baseDir));
-  const entries = await fs8.readdir(baseDir, { withFileTypes: true });
+  const entries = await fs10.readdir(baseDir, { withFileTypes: true });
   const folderNames = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -3186,7 +5173,7 @@ async function detectBlockChanges(conn, baseDir) {
       continue;
     const blockId = entry.name;
     folderNames.add(blockId);
-    const blockPath = path11.join(baseDir, blockId);
+    const blockPath = path14.join(baseDir, blockId);
     if (!syncedBlockIds.has(blockId)) {
       const tradelog = await findTradelogFile(blockPath);
       if (tradelog) {
@@ -3200,7 +5187,7 @@ async function detectBlockChanges(conn, baseDir) {
       continue;
     }
     try {
-      const tradelogPath = path11.join(blockPath, tradelogFilename);
+      const tradelogPath = path14.join(blockPath, tradelogFilename);
       const currentHash = versionedHash(await hashFileContent(tradelogPath));
       const metadata = await getSyncMetadata(conn, blockId, baseDir);
       if (!metadata || metadata.tradelog_hash !== currentHash) {
@@ -3208,7 +5195,7 @@ async function detectBlockChanges(conn, baseDir) {
       } else {
         const optionalLogs = await findOptionalLogFiles(blockPath);
         if (optionalLogs.reportinglog) {
-          const reportinglogPath = path11.join(blockPath, optionalLogs.reportinglog);
+          const reportinglogPath = path14.join(blockPath, optionalLogs.reportinglog);
           const reportingHash = versionedHash(await hashFileContent(reportinglogPath));
           if (metadata.reportinglog_hash !== reportingHash) {
             toSync.push(blockId);
@@ -3250,7 +5237,7 @@ function setBlocksDir(dir) {
 }
 function getBlocksDir(baseDir) {
   if (_blocksDir) return _blocksDir;
-  const nestedBlocksDir = path12.join(baseDir, "blocks");
+  const nestedBlocksDir = path15.join(baseDir, "blocks");
   return existsSync2(nestedBlocksDir) ? nestedBlocksDir : baseDir;
 }
 async function syncAllBlocks(baseDir) {
@@ -3269,7 +5256,7 @@ async function syncAllBlocks(baseDir) {
     }
   }
   for (const blockId of toSync) {
-    const blockPath = path12.join(blocksDir, blockId);
+    const blockPath = path15.join(blocksDir, blockId);
     const result = await syncBlockInternal(conn, blockId, blockPath);
     results.push(result);
     if (result.status === "error" && result.error) {
@@ -3288,9 +5275,9 @@ async function syncAllBlocks(baseDir) {
 async function syncBlock(blockId, baseDir) {
   const conn = await getConnection(baseDir);
   const blocksDir = getBlocksDir(baseDir);
-  const blockPath = path12.join(blocksDir, blockId);
+  const blockPath = path15.join(blocksDir, blockId);
   try {
-    await fs9.access(blockPath);
+    await fs11.access(blockPath);
   } catch {
     const existing = await getSyncMetadata(conn, blockId, blocksDir);
     if (existing) {
@@ -3305,6 +5292,35 @@ async function syncBlock(blockId, baseDir) {
 export {
   ensureMutableMarketTables,
   ensureMarketDataTables,
+  CANONICAL_JSON_VERSION,
+  canonicalJson,
+  canonicalJsonBytes,
+  addressCanonicalJson,
+  addressBytes,
+  parseCanonicalJsonAddress,
+  parseSha256Address,
+  ContentObjectCollisionError,
+  ContentObjectStore,
+  MARKET_DATASETS,
+  isRealMarketSessionDate,
+  marketDatasetDefinition,
+  canonicalPartitionDataset,
+  validatePartitionIdentity,
+  canonicalPartitionRelativePath,
+  PARTITION_COMMIT_RECEIPT_KIND,
+  PARTITION_COMMIT_RECEIPT_VERSION,
+  PARTITION_COMMIT_EVENT_KIND,
+  PARTITION_COMMIT_EVENT_VERSION,
+  INTERNAL_HISTORICAL_PARTITION_ADOPTION,
+  setPartitionCommitTestFault,
+  PartitionFileIntegrityError,
+  FilePartitionCommitStore,
+  publishRefreshCompletionAuthority,
+  verifyRefreshCompletionAuthority,
+  PartitionFilePublicationError,
+  runPartitionCommitAttempt,
+  activePartitionCommitAttempt,
+  capturePartitionCommitReceipt,
   resolveDbPath,
   setDataRoot,
   getDataRoot,
@@ -3321,8 +5337,12 @@ export {
   writeQuoteMinutesPartition,
   writeOiDailyPartition,
   writeEnrichedTickerFile,
+  writeEnrichedTickerPartition,
   writeEnrichedContext,
+  writeEnrichedContextPartition,
   isParquetMode,
+  ParquetProvenanceOrphanError,
+  UnmanifestedParquetWriteError,
   writeParquetAtomic,
   writeParquetPartition,
   writeJsonFile,
@@ -3369,12 +5389,6 @@ export {
   getProfile,
   listProfiles,
   deleteProfile,
-  escapeSqlLiteral,
-  readParquetFilesSql,
-  describeReadParquetColumns,
-  describeQueryColumns,
-  quoteParquetCanonicalProjection,
-  quoteParquetCanonicalWriteProjection,
   createMarketParquetViews,
   migrateMetadataToJson,
   getConnection,
@@ -3393,4 +5407,4 @@ export {
   loadReportingLog,
   importCsv
 };
-//# sourceMappingURL=chunk-4HZLVUOZ.js.map
+//# sourceMappingURL=chunk-5HBZ3TZM.js.map