@zackbart/connecta 0.37.0 → 0.38.0

package/dist/skills.js

@@ -1,3 +1,4 @@
+import { bytesToHex, utf8Length } from "./bytes.js";
 import { duringViewEffect } from "./runtime/call.js";
 import { RequestScope, requestOwner } from "./runtime/request-scope.js";
 import { upwardStep } from "./upward.js";
@@ -9,7 +10,7 @@ import { runEdge, withDeadlineEffect } from "./runtime/run.js";
 import { closeScopeOnExit } from "./runtime/connector-scope.js";
 import { sentSecretsForRequest } from "./sent-secrets.js";
 const ROUTE = "Choose a route before discovery. One known-address read uses call_tool; one known-address write uses call_destructive_tool. Unknown-address read-only work starts with execute_code to discover, call, and return the answer; use the same route for reduction, multiple or dependent calls, loops, joins, or branches. Keep discovery and calls together when schemas suffice; do not return catalog matches alone. Sample unfamiliar reads.";
-const RECOVERY = 'When an auth error includes a handoff, give it to the user or operator. Use authorize_connector for a fresh link. Page resultId notices and format:"paged" handles with connecta.result(handleOrId, { page? }). Fetch skills({ name: "usage" }) only for missing guidance or program repair.';
+const RECOVERY = 'When an auth error includes a handoff, give it to the user or operator. Use authorize_connector for a fresh link. Page resultId notices and format:"paged" handles with connecta.result(handleOrId, { page? }). Missing guidance/repair only: skills tool "usage" or connecta.skill("usage").';
 /**
  * The always-loaded MCP `instructions` string. An endpoint is writable or
  * read-only: a writable one lets programs and call_destructive_tool write,
@@ -328,25 +329,6 @@ const MAX_SKILL_CATALOG_BYTES = 8 * 1024 * 1024;
 const MAX_SKILLS = 1_024;
 const encoder = new TextEncoder();
 const PRIVATE = { resultType: "complete", ttlMs: 0, cacheScope: "private" };
-/** Bound metadata before cloning it, without another payload-sized byte array. */
-function jsonBytes(value) {
-    const json = JSON.stringify(value);
-    let bytes = 0;
-    for (let i = 0; i < json.length; i++) {
-        const code = json.charCodeAt(i);
-        if (code < 0x80)
-            bytes++;
-        else if (code < 0x800)
-            bytes += 2;
-        else if (code >= 0xd800 && code <= 0xdbff && json.charCodeAt(i + 1) >= 0xdc00 && json.charCodeAt(i + 1) <= 0xdfff) {
-            bytes += 4;
-            i++;
-        }
-        else
-            bytes += 3;
-    }
-    return bytes;
-}
 function localRecord(name, uri, description, content, aliases) {
     return { entry: { uri, frontmatter: { name, description }, resources: "dynamic" }, content, aliases };
 }
@@ -369,12 +351,7 @@ const localRecordsNative = /* @__PURE__ */ registerAuth(localRecords, function (
             (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)), (connector) => authFlow(function* () {
             const name = validSkillName(connector.id)
                 ? connector.id
-                : `connector-${[
-                    ...new Uint8Array(yield* upwardStep(authInvoke(crypto.subtle, "digest", ["SHA-256", encoder.encode(connector.id)]))),
-                ]
-                    .map((byte) => byte.toString(16).padStart(2, "0"))
-                    .join("")
-                    .slice(0, 48)}`;
+                : `connector-${bytesToHex(new Uint8Array(yield* upwardStep(authInvoke(crypto.subtle, "digest", ["SHA-256", encoder.encode(connector.id)])))).slice(0, 48)}`;
             const description = connectorGuideSummary(connector);
             const root = `skill://connecta/connectors/${encodeURIComponent(name)}`;
             const content = `---\n${JSON.stringify({ name, description }, null, 2)}\n---\n\n${connectorGuide(connector)}`;
@@ -474,11 +451,7 @@ const withManifestNative = /* @__PURE__ */ registerAuth(withManifest, function (
         const bytes = encoder.encode(record.content);
         if (bytes.length > MAX_SKILL_BYTES)
             throw new ConnectorCallError("unavailable", "Local skill exceeds the byte bound.");
-        const digest = [
-            ...new Uint8Array(yield* upwardStep(authInvoke(crypto.subtle, "digest", ["SHA-256", bytes]))),
-        ]
-            .map((byte) => byte.toString(16).padStart(2, "0"))
-            .join("");
+        const digest = bytesToHex(new Uint8Array(yield* upwardStep(authInvoke(crypto.subtle, "digest", ["SHA-256", bytes]))));
         return {
             ...record,
             entry: {
@@ -723,7 +696,7 @@ export class SkillsRegistry {
                 const records = yield* upwardStep(Effect.forEach(yield* upwardStep(self.local), (record) => authCall(withManifest, [record]), {
                     concurrency: "unbounded",
                 }));
-                let catalogBytes = jsonBytes(records.map((record) => record.entry));
+                let catalogBytes = utf8Length(JSON.stringify(records.map((record) => record.entry)));
                 // Bounded sequential connector reads avoid unbounded fan-out and finish
                 // cleanup before a later connector's failure can end the whole listing.
                 for (const connector of self.registry.listConnectors()) {
@@ -736,7 +709,7 @@ export class SkillsRegistry {
                     if (!Array.isArray(entries) || records.length + entries.length > MAX_SKILLS)
                         throw new ConnectorCallError("unavailable", "Downstream skills listing exceeds its bound.");
                     for (const original of entries) {
-                        if (catalogBytes + jsonBytes(original) + 1 > MAX_SKILL_CATALOG_BYTES)
+                        if (catalogBytes + utf8Length(JSON.stringify(original)) + 1 > MAX_SKILL_CATALOG_BYTES)
                             throw new ConnectorCallError("unavailable", "Skills listing exceeds its byte bound.");
                         const entry = structuredClone(original);
                         validateEntry(entry);
@@ -758,14 +731,14 @@ export class SkillsRegistry {
                         if (records.some((record) => record.entry.uri === uri))
                             throw new ConnectorCallError("unavailable", "Downstream skills listing contains duplicate entries.");
                         const mapped = { ...entry, uri, resources };
-                        catalogBytes += jsonBytes(mapped) + 1;
+                        catalogBytes += utf8Length(JSON.stringify(mapped)) + 1;
                         if (catalogBytes > MAX_SKILL_CATALOG_BYTES)
                             throw new ConnectorCallError("unavailable", "Skills listing exceeds its byte bound.");
                         records.push({ entry: mapped, aliases: [], connector, files });
                     }
                 }
                 if (records.length > MAX_SKILLS ||
-                    jsonBytes(records.map((record) => record.entry)) > MAX_SKILL_CATALOG_BYTES) {
+                    utf8Length(JSON.stringify(records.map((record) => record.entry))) > MAX_SKILL_CATALOG_BYTES) {
                     throw new ConnectorCallError("unavailable", "Skills listing exceeds its byte or entry bound.");
                 }
                 // Keep the old investigation guide behind every connector and downstream

package/dist/sqlite.d.ts

@@ -27,22 +27,3 @@ export declare function sqliteStorage(database: SqliteDatabase): KVStorage;
  * older than `retentionDays`.
  */
 export declare function sqliteActivityStore(database: SqliteDatabase, options?: SqliteActivityOptions): ActivityStore;
-export interface StateFileImport {
-    /** Entries copied into the database. */
-    imported: number;
-    /** Entries left alone because the database already held their key. */
-    kept: number;
-    /** Entries whose TTL had already passed. */
-    expired: number;
-}
-/**
- * One-shot migration from the 0.28 `fileStorage` JSON state file: copy every
- * live entry, with its expiry, into the database's key-value table. Run it
- * once, with the old deployment stopped, before the first start on SQLite.
- *
- * Keys the database already holds are kept, so a second run copies nothing
- * twice and never overwrites state written since. The file is read, never
- * changed; delete it once the deployment is verified. A file that is not a
- * state file throws before anything is written.
- */
-export declare function importStateFile(database: SqliteDatabase, statePath: string, now?: number): StateFileImport;

package/dist/sqlite.js

@@ -4,12 +4,11 @@
 // install. `sqliteStorage` is the deployment's `KVStorage` and
 // `sqliteActivityStore` its activity history; both create their tables on
 // first use. Node-only: nothing reachable from the root entry imports this.
-import { chmodSync, closeSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { chmodSync, closeSync, mkdirSync, openSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { effectSqlDriver, sqlDriverEdge, sqlSync } from "./storage/sql-driver.js";
-import { validateStorageKey } from "./storage/keys.js";
-import { KV_SCHEMA, sqlActivityStore, sqlStorage, } from "./storage/sql.js";
+import { sqlActivityStore, sqlStorage, } from "./storage/sql.js";
 /** Milliseconds a write waits for another process's write lock. */
 const BUSY_TIMEOUT_MS = 5_000;
 /**
@@ -100,83 +99,3 @@ export function sqliteStorage(database) {
 export function sqliteActivityStore(database, options) {
     return sqlActivityStore(sqliteDriver(database), "sqlite", options);
 }
-/**
- * One-shot migration from the 0.28 `fileStorage` JSON state file: copy every
- * live entry, with its expiry, into the database's key-value table. Run it
- * once, with the old deployment stopped, before the first start on SQLite.
- *
- * Keys the database already holds are kept, so a second run copies nothing
- * twice and never overwrites state written since. The file is read, never
- * changed; delete it once the deployment is verified. A file that is not a
- * state file throws before anything is written.
- */
-export function importStateFile(database, statePath, now = Date.now()) {
-    const text = readFileSync(statePath, "utf8");
-    // The file holds stored state (tokens, sealed credentials), and these
-    // errors reach the operator's terminal, so they name the file and an entry's
-    // position, never a key or the parser's account, which quotes the text.
-    let loaded;
-    try {
-        loaded = JSON.parse(text);
-    }
-    catch {
-        throw new TypeError(`${statePath} is not a connecta state file: it is not valid JSON`);
-    }
-    if (loaded === null || typeof loaded !== "object" || Array.isArray(loaded)) {
-        throw new TypeError(`${statePath} is not a connecta state file`);
-    }
-    const entries = Object.entries(loaded);
-    for (const [index, [key, entry]] of entries.entries()) {
-        validateStorageKey(key);
-        const valid = entry !== null &&
-            typeof entry === "object" &&
-            typeof entry.value === "string" &&
-            (!("exp" in entry) || Number.isFinite(entry.exp));
-        if (!valid) {
-            throw new TypeError(`${statePath} is not a connecta state file: entry ${index + 1} has no string value`);
-        }
-    }
-    let db;
-    let transaction = false;
-    let step = "open the SQLite database";
-    const result = { imported: 0, kept: 0, expired: 0 };
-    try {
-        db = typeof database === "string" ? openSqlite(database) : database;
-        step = "begin the import transaction";
-        db.exec("BEGIN IMMEDIATE");
-        transaction = true;
-        step = "prepare the key-value table";
-        for (const statement of KV_SCHEMA)
-            db.exec(statement);
-        const insert = db.prepare(`INSERT INTO connecta_kv (key, value, expires_at_ms) VALUES (?, ?, ?)
-       ON CONFLICT (key) DO NOTHING`);
-        for (const [index, [key, entry]] of entries.entries()) {
-            step = `import entry ${index + 1} into the key-value table`;
-            const { value, exp } = entry;
-            if (exp !== undefined && exp <= now) {
-                result.expired += 1;
-                continue;
-            }
-            if (Number(insert.run(key, value, exp === undefined ? null : Math.ceil(exp)).changes) > 0) {
-                result.imported += 1;
-            }
-            else {
-                result.kept += 1;
-            }
-        }
-        step = "commit the import transaction";
-        db.exec("COMMIT");
-    }
-    catch {
-        if (transaction) {
-            try {
-                db.exec("ROLLBACK");
-            }
-            catch {
-                // Rollback errors can contain stored text too. Report the failed step.
-            }
-        }
-        throw new Error(`State import failed: could not ${step}`);
-    }
-    return result;
-}

package/dist/storage/keys.js

@@ -73,6 +73,19 @@ export const resultKeys = {
     chunk: (id, index) => validateStorageKey(index === 0 ? `result:${id}` : `result:${id}#${index}`),
 };
 // --- root families --------------------------------------------------------
+/** Random key for opaque operator viewer partitions; never leaves storage. */
+export const operatorViewerKeys = {
+    family: {
+        name: "operator-viewer-key",
+        scope: "root",
+        prefixes: ["operator-viewer:v1:"],
+        version: { number: 1, in: "key" },
+        codec: textCodec,
+        ttl: { kind: "durable" },
+        durable: false,
+    },
+    signingKey: "operator-viewer:v1:signing",
+};
 /** A deployment's random HMAC key for bound continuation cursors; never expires or leaves storage. */
 export const continuationKeys = {
     family: {
@@ -128,7 +141,7 @@ export const catalogKeys = {
         name: "catalog",
         scope: "root",
         prefixes: ["catalog:"],
-        // Retired v2/v3 listings are inventoried for migration; no runtime reads them.
+        // Retired v2/v3 listings expire on their original TTL; no runtime reads them.
         version: { number: 3, in: "value" },
         codec: textCodec,
         ttl: {
@@ -229,38 +242,6 @@ export const credentialKeys = {
     },
     credential: (connectorId, owner) => `${owner ? scopes.principal(owner) : ""}${scopes.connector(connectorId)}credential:v1`,
 };
-/** Seconds a Workers KV → D1 copy's resume point stays usable. */
-export const KV_COPY_CURSOR_TTL_SECONDS = 7 * 24 * 60 * 60;
-/**
- * Where a one-shot Workers KV → D1 copy (`copyKvToD1` in `src/d1.ts`) resumes,
- * held in D1 under a random token. Workers KV's own list cursor can spell the
- * last key it listed, so the caller holds the token and never the cursor.
- */
-export const kvCopyKeys = {
-    family: {
-        name: "kv-copy",
-        scope: "root",
-        prefixes: ["kv-copy:v1:"],
-        version: { number: 1, in: "key" },
-        codec: textCodec,
-        ttl: { kind: "fixed", seconds: KV_COPY_CURSOR_TTL_SECONDS },
-        durable: false,
-    },
-    cursor: (token) => validateStorageKey(`kv-copy:v1:cursor:${token}`),
-};
-/** Once traffic uses D1, copying stale KV state is refused. */
-export const kvCutoverKeys = {
-    family: {
-        name: "kv-cutover",
-        scope: "root",
-        prefixes: ["kv-cutover:v1:"],
-        version: { number: 1, in: "key" },
-        codec: textCodec,
-        ttl: { kind: "durable" },
-        durable: true,
-    },
-    source: (source) => validateStorageKey(`kv-cutover:v1:${encodeURIComponent(source)}`),
-};
 // --- connector families ---------------------------------------------------
 /** Seconds a consent's flow record stays claimable, the same as its link. */
 export const OAUTH_FLOW_TTL_SECONDS = 15 * 60;
@@ -343,38 +324,6 @@ export const oauthRefreshActiveKeys = {
     prefix: "oauth:refresh-active:",
     holder: (epoch, holder) => validateStorageKey(`oauth:refresh-active:${epoch}:${holder}`),
 };
-/** The values layout 2 stored, each under its historical key. */
-const oauthV2Field = {
-    client: "oauth:client",
-    tokens: "oauth:tokens",
-    pending: "oauth:pending",
-    verifier: "oauth:verifier",
-    state: "oauth:state",
-    discovery: "oauth:discovery",
-};
-/**
- * Layout 2, read once to migrate it into a grant record and then deleted:
- * each value at its field key, suffixed `:epoch:<generation>` once a modern
- * generation owned it; the active generation at `oauth:generation`; a reset's
- * cleanup lineage at `oauth:cleanup:` and `oauth:cleanup-at:`.
- */
-export const oauthV2Keys = {
-    family: {
-        name: "oauth-v2",
-        scope: "connector",
-        prefixes: [...Object.values(oauthV2Field), "oauth:generation", "oauth:cleanup:", "oauth:cleanup-at:"],
-        version: { number: 2, in: "value" },
-        codec: textCodec,
-        ttl: { kind: "durable" },
-        durable: true,
-    },
-    field: oauthV2Field,
-    /** One listing covers every layout 2 key; the reader keeps those above. */
-    scan: "oauth:",
-    /** A value's physical key; `epoch` null is the historical unsuffixed name. */
-    value: (key, epoch) => validateStorageKey(epoch === null ? key : `${key}:epoch:${epoch}`),
-    generation: "oauth:generation",
-};
 /** Single-use browser links (`used`/`started`/`failed`/`closed`) and MRTR rounds. */
 export const oauthConnectKeys = {
     family: {
@@ -417,62 +366,18 @@ export const inputRetryKeys = {
     },
     used: (nonce) => validateStorageKey(`input-retry:v1:${nonce}`),
 };
-/**
- * Every family, for the overlap and coverage checks and for migrations that
- * copy only what a deployment cannot recreate. Keys a custom connector writes
- * through its own `ctx.storage` belong to that connector, inside its
- * namespace, and are not listed here.
- */
-export const KEY_FAMILIES = [
-    continuationKeys.family,
-    resultKeys.family,
-    stashLedgerKeys.family,
-    stashExpiryKeys.family,
-    catalogKeys.family,
-    responseCacheKeys.family,
-    oauthHandoffKeys.family,
-    accessTokenKeys.family,
-    agentObservationKeys.family,
-    credentialKeys.family,
-    oauthGrantKeys.family,
-    oauthFlowKeys.family,
-    oauthRefreshKeys.family,
-    oauthRefreshSpentKeys.family,
-    oauthRefreshActiveKeys.family,
-    oauthV2Keys.family,
-    oauthConnectKeys.family,
-    negotiationKeys.family,
-    inputRetryKeys.family,
-    kvCopyKeys.family,
-    kvCutoverKeys.family,
-];
-// Principal, connector, and subject segments are hex digests and connector
-// ids, so none holds a colon.
-const PRINCIPAL_SCOPE = /^principal:[^:]*:/;
-const CONNECTOR_SCOPE = /^conn:[^:]*:/;
-const PARTITION_SCOPE = /^(?:results:|subject:[^:]*:)/;
-/**
- * The family a physical key belongs to, for reports that count keys without
- * naming them: one-shot migrations report per family, never per key. A key
- * no family claims is `connector-owned` when a custom connector wrote it
- * through its own `ctx.storage`, and `unclassified` otherwise (a key an older release wrote).
- */
-export function familyOfKey(key) {
-    let rest = key.replace(PRINCIPAL_SCOPE, "");
-    let scope = "root";
-    for (const [pattern, nested] of [
-        [CONNECTOR_SCOPE, "connector"],
-        [PARTITION_SCOPE, "partition"],
-    ]) {
-        const match = pattern.exec(rest);
-        if (match) {
-            rest = rest.slice(match[0].length);
-            scope = nested;
-            break;
-        }
-    }
-    const family = KEY_FAMILIES.find((candidate) => candidate.scope === scope && candidate.prefixes.some((prefix) => rest.startsWith(prefix)));
-    if (family)
-        return family.name;
-    return scope === "connector" ? "connector-owned" : "unclassified";
-}
+/** Retired OAuth names are inspected only to report that fresh consent is required. */
+export const retiredOAuthKeys = {
+    scan: "oauth:",
+    prefixes: [
+        "oauth:client",
+        "oauth:tokens",
+        "oauth:pending",
+        "oauth:verifier",
+        "oauth:state",
+        "oauth:discovery",
+        "oauth:generation",
+        "oauth:cleanup:",
+        "oauth:cleanup-at:",
+    ],
+};

package/dist/storage/sql-native.js

@@ -5,9 +5,9 @@
 // three methods; nothing in this module knows which one it has. It imports no
 // platform module, so the Worker subpath can carry it.
 //
-// Atomicity. Every compare-and-set is one statement. SQLite executes a
-// statement atomically against the database file, and D1 runs one database's
-// statements one at a time against its primary, so a comparison and its write
+// Atomicity. Every compare-and-set comparison and mutation share one statement.
+// SQLite executes a statement atomically against the database file, and D1
+// runs one database's statements one at a time against its primary, so a comparison and its write
 // cannot interleave with another request's: of fifty concurrent claims on an
 // absent key, exactly one changes a row.
 //
@@ -77,6 +77,13 @@ export function nativeSqlStorage(driver) {
     // SQLite and D1 evaluate 'now' in the database, never in a caller isolate.
     const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
     const live = `(expires_at_ms IS NULL OR expires_at_ms > ${now})`;
+    const expirySweep = () => sql(`DELETE FROM connecta_kv WHERE key IN (
+      SELECT key FROM connecta_kv WHERE expires_at_ms <= ${now} LIMIT ${SWEEP_ROWS}
+    )`);
+    // One atomic batch, one round trip, as `set()` pays. The comparison and
+    // mutation stay one statement; only its affected-row count decides the
+    // result, never the sweep's.
+    const runCas = (statement) => Effect.map(driver.batch([expirySweep(), statement]), (changes) => changes[1] ?? 0);
     const expiryOptions = (opts) => {
         if (opts?.expiresAtMs !== undefined) {
             if (!Number.isSafeInteger(opts.expiresAtMs) || opts.ttlSeconds !== undefined) {
@@ -104,9 +111,7 @@ export function nativeSqlStorage(driver) {
                 yield* ensure();
                 const expiry = expiryOptions(opts);
                 yield* driver.batch([
-                    sql(`DELETE FROM connecta_kv WHERE key IN (
-            SELECT key FROM connecta_kv WHERE expires_at_ms <= ${now} LIMIT ${SWEEP_ROWS}
-          )`),
+                    expirySweep(),
                     sql(`INSERT INTO connecta_kv (key, value, expires_at_ms)
            VALUES (?, ?, ${expiry.expression})
            ON CONFLICT (key) DO UPDATE SET
@@ -143,8 +148,7 @@ export function nativeSqlStorage(driver) {
                     return (yield* current(key)) === null;
                 }
                 if (next === null) {
-                    return ((yield* driver.run(sql(`DELETE FROM connecta_kv WHERE key = ? AND ${live} AND value = ?`, key, expected))) >
-                        0);
+                    return ((yield* runCas(sql(`DELETE FROM connecta_kv WHERE key = ? AND ${live} AND value = ?`, key, expected))) > 0);
                 }
                 let expiry;
                 try {
@@ -160,120 +164,19 @@ export function nativeSqlStorage(driver) {
                 if (expected === null) {
                     // Insert, or take over a row that has expired. A live row makes the
                     // upsert's WHERE false, so nothing changes and the claim is refused.
-                    return ((yield* driver.run(sql(`INSERT INTO connecta_kv (key, value, expires_at_ms)
+                    return ((yield* runCas(sql(`INSERT INTO connecta_kv (key, value, expires_at_ms)
            VALUES (?, ?, ${expiry.expression})
            ON CONFLICT (key) DO UPDATE SET
              value = excluded.value, expires_at_ms = excluded.expires_at_ms
            WHERE connecta_kv.expires_at_ms IS NOT NULL
              AND connecta_kv.expires_at_ms <= ${now}`, key, next, expiry.value))) > 0);
                 }
-                return ((yield* driver.run(sql(`UPDATE connecta_kv SET value = ?, expires_at_ms = ${expiry.expression}
+                return ((yield* runCas(sql(`UPDATE connecta_kv SET value = ?, expires_at_ms = ${expiry.expression}
          WHERE key = ? AND ${live} AND value = ?`, next, expiry.value, key, expected))) > 0);
             });
         },
     };
 }
-/** Keys one read compares: D1 binds at most 100 parameters, one is `now`. */
-const COPY_READ_KEYS = 99;
-/** Writes one transaction carries, by count and by UTF-8 bytes. */
-const COPY_BATCH_STATEMENTS = 50;
-const COPY_BATCH_BYTES = 4 * 1024 * 1024;
-/**
- * Copy entries into the key-value table, verbatim: same key, same value,
- * same absolute expiry. A live row holding a different value is kept unless
- * `overwrite` is set, so a second copy of the same entries writes nothing.
- * Writes go out in bounded transactions; the outcomes follow `entries`.
- */
-export function copyIntoSqlEffect(driver, entries, options) {
-    return Effect.gen(function* () {
-        const { overwrite, now } = options;
-        for (const entry of entries)
-            validateStorageKey(entry.key);
-        yield* driver.batch(KV_SCHEMA.map((statement) => sql(statement)));
-        const live = "(expires_at_ms IS NULL OR expires_at_ms > ?)";
-        const currentValues = (keys) => Effect.gen(function* () {
-            const values = new Map();
-            for (let start = 0; start < keys.length; start += COPY_READ_KEYS) {
-                const chunk = keys.slice(start, start + COPY_READ_KEYS);
-                const rows = yield* driver.all(sql(`SELECT key, ${textColumn("value")}, expires_at_ms FROM connecta_kv
-         WHERE key IN (${chunk.map(() => "?").join(", ")}) AND ${live}`, ...chunk, now));
-                // The message names no key: a copy's errors reach operator output.
-                for (const row of rows) {
-                    values.set(row.key, {
-                        value: textOf(row.value, row.value_bytes, "a stored value") ?? "",
-                        expiresAtMs: row.expires_at_ms,
-                    });
-                }
-            }
-            return values;
-        });
-        const outcomes = Array.from({ length: entries.length });
-        const writes = [];
-        const existing = yield* currentValues(entries.map((entry) => entry.key));
-        for (const [index, entry] of entries.entries()) {
-            const current = existing.get(entry.key);
-            if (current?.value === entry.value && current.expiresAtMs === entry.expiresAtMs) {
-                outcomes[index] = "unchanged";
-            }
-            else if (current !== undefined && !overwrite) {
-                outcomes[index] = "conflict";
-            }
-            else {
-                outcomes[index] = current === undefined ? "copied" : "overwritten";
-                writes.push({
-                    index,
-                    bytes: new TextEncoder().encode(entry.key).byteLength + new TextEncoder().encode(entry.value).byteLength + 32,
-                    statement: overwrite
-                        ? sql(`INSERT INTO connecta_kv (key, value, expires_at_ms)
-               VALUES (?, ?, ?)
-               ON CONFLICT (key) DO UPDATE SET
-                 value = excluded.value, expires_at_ms = excluded.expires_at_ms`, entry.key, entry.value, entry.expiresAtMs)
-                        : // Absent when read; a live row written since is kept, not replaced.
-                            sql(`INSERT INTO connecta_kv (key, value, expires_at_ms)
-               VALUES (?, ?, ?)
-               ON CONFLICT (key) DO UPDATE SET
-                 value = excluded.value, expires_at_ms = excluded.expires_at_ms
-               WHERE connecta_kv.expires_at_ms IS NOT NULL
-                 AND connecta_kv.expires_at_ms <= ?`, entry.key, entry.value, entry.expiresAtMs, now),
-                });
-            }
-        }
-        const raced = [];
-        let batch = [];
-        let batchBytes = 0;
-        const flush = () => Effect.gen(function* () {
-            if (batch.length === 0)
-                return;
-            const changes = yield* driver.batch(batch.map((write) => write.statement));
-            for (const [position, write] of batch.entries()) {
-                if (!(changes[position] > 0))
-                    raced.push(write.index);
-            }
-            batch = [];
-            batchBytes = 0;
-        });
-        for (const write of writes) {
-            if (batch.length > 0 && (batch.length >= COPY_BATCH_STATEMENTS || batchBytes + write.bytes > COPY_BATCH_BYTES)) {
-                yield* flush();
-            }
-            batch.push(write);
-            batchBytes += write.bytes;
-        }
-        yield* flush();
-        // A row another writer added between the read and the write: report what
-        // it holds, and leave it.
-        if (raced.length > 0) {
-            const after = yield* currentValues(raced.map((index) => entries[index].key));
-            for (const index of raced) {
-                const entry = entries[index];
-                const current = after.get(entry.key);
-                outcomes[index] =
-                    current?.value === entry.value && current.expiresAtMs === entry.expiresAtMs ? "unchanged" : "conflict";
-            }
-        }
-        return outcomes;
-    });
-}
 // --- activity -----------------------------------------------------------
 /**
  * The activity table, with keyset paging on `(occurred_at_ms, id)`. Its shape

package/dist/storage/sql.d.ts

@@ -1,7 +1,5 @@
 import type { ActivityStore } from "../activity.js";
 import type { KVStorage } from "../types.js";
-/** The 0.28-compatible key-value table and expiry index. */
-export { KV_SCHEMA } from "./sql-schema.js";
 type SqlValue = string | number | null;
 export interface SqlStatement {
     readonly sql: string;
@@ -21,18 +19,6 @@ export interface SqlDriver {
 }
 /** The two drivers, as `describe()` names them. */
 export type SqlKind = "d1" | "sqlite";
-export interface SqlCopyEntry {
-    readonly key: string;
-    readonly value: string;
-    /** Epoch milliseconds; null never expires. */
-    readonly expiresAtMs: number | null;
-}
-/**
- * What a copy did with one entry: written where no live row was, left alone
- * because the live row already held the value, refused because it held
- * another (`conflict`), or replaced under `overwrite` (`overwritten`).
- */
-export type SqlCopyOutcome = "copied" | "unchanged" | "conflict" | "overwritten";
 export interface SqlActivityOptions {
     /**
      * Days of history kept. Each write removes a bounded batch of older rows,
@@ -48,13 +34,4 @@ export declare function sqlStorage(driver: SqlDriver, kind: SqlKind): KVStorage;
  * payload to leak.
  */
 export declare function sqlActivityStore(driver: SqlDriver, kind: SqlKind, options?: SqlActivityOptions): ActivityStore;
-/**
- * Copy entries into the key-value table, verbatim: same key, same value,
- * same absolute expiry. A live row holding a different value is kept unless
- * `overwrite` is set, so a second copy of the same entries writes nothing.
- * Writes go out in bounded transactions; the outcomes follow `entries`.
- */
-export declare function copyIntoSql(driver: SqlDriver, entries: readonly SqlCopyEntry[], options: {
-    overwrite: boolean;
-    now: number;
-}): Promise<SqlCopyOutcome[]>;
+export {};

package/dist/storage/sql.js

@@ -1,9 +1,7 @@
 import { runEdge } from "../runtime/run.js";
 import { registerNativeStorage, registerNativeActivity } from "../runtime/native-storage.js";
 import { nativeSqlDriver } from "./sql-driver.js";
-import { nativeSqlStorage, nativeSqlActivityStore, copyIntoSqlEffect } from "./sql-native.js";
-/** The 0.28-compatible key-value table and expiry index. */
-export { KV_SCHEMA } from "./sql-schema.js";
+import { nativeSqlStorage, nativeSqlActivityStore } from "./sql-native.js";
 /** `KVStorage` over one `connecta_kv` table. */
 export function sqlStorage(driver, kind) {
     const native = nativeSqlStorage(nativeSqlDriver(driver));
@@ -30,12 +28,3 @@ export function sqlActivityStore(driver, kind, options = {}) {
         list: (options) => runEdge(native.list(options)),
     }, native);
 }
-/**
- * Copy entries into the key-value table, verbatim: same key, same value,
- * same absolute expiry. A live row holding a different value is kept unless
- * `overwrite` is set, so a second copy of the same entries writes nothing.
- * Writes go out in bounded transactions; the outcomes follow `entries`.
- */
-export function copyIntoSql(driver, entries, options) {
-    return runEdge(copyIntoSqlEffect(nativeSqlDriver(driver), entries, options));
-}

package/dist/tool-error.js

@@ -0,0 +1,4 @@
+export function toolError(error, fields = {}) {
+    const structuredContent = { ...fields, error };
+    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent, isError: true };
+}