@north-light/cli 0.3.579 → 0.3.581

package/dist/core/import/bundle/blob-keys.d.ts

@@ -0,0 +1,10 @@
+export declare const runBlobPrefix: (run: string) => string;
+export declare const runBlobKey: (run: string, key: string) => string;
+/** `node`: the owner is a node id of the bundle; `request`: a human request id of the bundle. */
+export interface ParsedBlobKey {
+    kind: 'conversation' | 'attachment' | 'job' | 'event' | 'request';
+    ownerTable: 'nodes' | 'human_requests';
+    owner: string;
+}
+/** The key's kind and owner, or null when it is none of the keys cycle 5 reads (or has an empty, `.` or `..` segment). */
+export declare function parseBlobKey(key: string): ParsedBlobKey | null;

package/dist/core/import/bundle/blob-keys.js

@@ -0,0 +1 @@
+var r=Object.defineProperty;var n=(t,e)=>r(t,"name",{value:e,configurable:!0});const u=n(t=>`imports/${t}/blobs/`,"runBlobPrefix"),c=n((t,e)=>`${u(t)}${e}`,"runBlobKey"),a=[["conversation",/^conversations\/([^/]+)\/[^/]+\/[^/]+$/],["attachment",/^attachments\/([^/]+)\/[0-9a-f]{64}$/],["job",/^jobs\/([^/]+)\/[^/]+\/output(?:\/\d{8})?$/],["event",/^events\/([^/]+)\/\d{16}-\d{16}-[0-9a-f]{32}\.jsonl\.zst$/],["request",/^requests\/([^/]+)\/.+$/]];function i(t){if(t.split("/").some(e=>e===""||e==="."||e===".."))return null;for(const[e,s]of a){const o=s.exec(t);if(o!==null)return{kind:e,ownerTable:e==="request"?"human_requests":"nodes",owner:o[1]}}return null}n(i,"parseBlobKey");export{i as parseBlobKey,c as runBlobKey,u as runBlobPrefix};

package/dist/core/import/bundle/layout.d.ts

@@ -0,0 +1,89 @@
+/** `bodies` (revision text, design-fleet D106) is copied like any table but dumped apart: its 667 MB do not fit one row file (`encodeRows` builds one string), so its rows
+ *  travel as the part files named in `source.bodyParts` (see `rowKeys`), each written and read a line at a time (`RowFileWriter`, `rowLines`). */
+export declare const BODIES_TABLE = "bodies";
+/** Tables whose rows are dumped, staged and (after rewrites) copied, in no particular order: the lane computes the copy
+ *  order from the target's foreign-key catalog. Each row file holds the table's rows in primary-key order (identity-ordered
+ *  tables in source `seq` order). */
+export declare const COPIED_TABLES: readonly ["objects", "documents", "revisions", "revision_parents", "identities", "jobs", "custom_objects", "context_sessions", "environments", "object_kinds", "edges", "watches", "watch_subscriptions", "exposures", "rules", "unresolved_links", "nodes", "sessions", "worktrees", "node_faults", "waits", "structured_requests", "memory_reads", "deleted_isolated_nodes", "node_outcome_deliveries", "run_events", "messages", "message_causes", "deliveries", "crons", "cron_runs", "daemon_actions", "human_requests", "human_action_deliveries", "review_comments", "review_comment_events", "audit_rows", "app_users", "idempotency_keys", "uploads", "upload_uses", "shares", "provider_approvals", "relations", "charges", "limits", "conversation_parts", "conversation_entries", "profiles", "bodies"];
+/** Dumped and staged so rewrite 2 can map them, never inserted into the target (`grants`: the directory writes them). */
+export declare const STAGED_ONLY_TABLES: readonly ["grants"];
+/** Every table the exporter dumps. */
+export declare const DUMPED_TABLES: readonly string[];
+/** Tables with an identity primary key, tracked in `import_key_map` (source key → target key). */
+export declare const KEY_MAPPED_TABLES: {
+    readonly audit_rows: "id";
+    readonly review_comment_events: "seq";
+    readonly app_users: "uid";
+};
+/** Tables the target numbers by `seq`/identity in source order (the staged `seq` is not carried over). */
+export declare const SEQ_TABLES: readonly ["objects", "revisions", "watches", "watch_subscriptions", "sessions", "waits", "structured_requests", "deliveries", "run_events"];
+export declare const bundleKeys: {
+    readonly prefix: (run: string) => string;
+    readonly rows: (run: string, table: string) => string;
+    readonly source: (run: string) => string;
+    readonly manifest: (run: string) => string;
+    readonly nodeFiles: (run: string, node: string) => string;
+    readonly bodyRows: (run: string, part: string) => string;
+    readonly request: (requestId: string, relative: string) => string;
+};
+/** The blob keys of a table's row files: one file, or for `bodies` its parts. */
+export declare function rowKeys(run: string, table: string, source: Pick<SourceJson, 'bodyParts'>): string[];
+/** `imports/<run>/source.json`. */
+export interface SourceJson {
+    installId: string;
+    kind: 'machine' | 'hosted';
+    /** The source's person (`user:<id>`, or the local person on a runtime that never joined). */
+    person: string;
+    release: string;
+    schemaVersion: number;
+    /** Rows per dumped table. The lane refuses a row file whose line count differs. */
+    counts: Record<string, number>;
+    /** The source's machine environment object id, when it has one (`environments.object`). */
+    environmentObject?: string;
+    /** Hosted sources: every directory the exporter archived for a running node (`nodeFiles` holds its entries as `<from minus leading slash>/<relative path>`).
+     *  The lane picks the sandbox directory each one lands in (`sandboxPathMap`); the exporter does not. */
+    pathPrefixes?: PathPrefix[];
+    /** The part files of the `bodies` rows (`imports/<run>/rows/bodies/<part>.jsonl.zst`): the pre-pause dump's parts, then the pause dump's. `counts.bodies` is their total. */
+    bodyParts?: string[];
+    /** Shipped documents (`documents.source_path` set): document object id → hash of the body text the exporter read from its file; that text is a `bodies` row in the bundle.
+     *  The lane uses it for a shipped document the target has no copy of, which becomes an ordinary document (I23). */
+    shippedBodies?: Record<string, string>;
+}
+/** One archived directory of a running node: `app` is its grantee (`app:<slug>`), `role` says which directory it is. */
+export interface PathPrefix {
+    node: string;
+    app: string;
+    role: 'context' | 'worktree' | 'cwd';
+    from: string;
+}
+/** Rewrite 4: source path prefix → target path prefix, applied to the rows of running nodes of a hosted source. */
+export interface PathMapEntry {
+    from: string;
+    to: string;
+}
+export type PathMap = readonly PathMapEntry[];
+/** Rewrite one path through the map: the longest matching prefix wins; a path under no prefix is returned unchanged. */
+export declare function mapPath(map: PathMap, path: string): string;
+export type RowObject = Record<string, unknown>;
+/** Row-file codec: one JSON object per line, newline-terminated, zstd-compressed. */
+export declare function encodeRows(rows: Iterable<RowObject>): Buffer;
+export declare function decodeRows(data: Buffer | Uint8Array): RowObject[];
+/** One JSON object per line, newline-terminated: the line `RowFileWriter.write` takes. */
+export declare function rowLine(row: RowObject): string;
+/** Writes a row file as a zstd stream, a line at a time, so no string larger than one line exists (`encodeRows` builds the whole file as one string, past V8's
+ *  ~512 MiB string limit for a large file). `bytes` is the size of the JSON written so far, before compression. */
+export declare class RowFileWriter {
+    private readonly zst;
+    private readonly finished;
+    private written;
+    constructor(path: string);
+    get bytes(): number;
+    /** Write one line (`rowLine`), waiting for the compressor when it is full. */
+    write(line: string, size?: number): Promise<void>;
+    /** Finish the file; resolves when it is on disk. */
+    close(): Promise<void>;
+    destroy(): void;
+}
+/** The lines of a zstd row file, decompressed as a stream: each yielded string is one line (without its newline), so memory is one line plus a chunk. A file whose last
+ *  line is not newline-terminated, or that is not valid zstd, throws when the reader reaches it. */
+export declare function rowLines(data: Buffer | Uint8Array): AsyncGenerator<string>;

package/dist/core/import/bundle/layout.js

@@ -0,0 +1,5 @@
+var a=Object.defineProperty;var r=(s,e)=>a(s,"name",{value:e,configurable:!0});import{once as d}from"node:events";import{createWriteStream as u}from"node:fs";import{pipeline as f}from"node:stream/promises";import{createZstdCompress as m,createZstdDecompress as p,zstdCompressSync as l,zstdDecompressSync as _}from"node:zlib";const h="bodies",w=["objects","documents","revisions","revision_parents","identities","jobs","custom_objects","context_sessions","environments","object_kinds","edges","watches","watch_subscriptions","exposures","rules","unresolved_links","nodes","sessions","worktrees","node_faults","waits","structured_requests","memory_reads","deleted_isolated_nodes","node_outcome_deliveries","run_events","messages","message_causes","deliveries","crons","cron_runs","daemon_actions","human_requests","human_action_deliveries","review_comments","review_comment_events","audit_rows","app_users","idempotency_keys","uploads","upload_uses","shares","provider_approvals","relations","charges","limits","conversation_parts","conversation_entries","profiles","bodies"],x=["grants"],E=[...w,...x],z={audit_rows:"id",review_comment_events:"seq",app_users:"uid"},$=["objects","revisions","watches","watch_subscriptions","sessions","waits","structured_requests","deliveries","run_events"],c={prefix:r(s=>`imports/${s}/`,"prefix"),rows:r((s,e)=>`imports/${s}/rows/${e}.jsonl.zst`,"rows"),source:r(s=>`imports/${s}/source.json`,"source"),manifest:r(s=>`imports/${s}/manifest.jsonl.zst`,"manifest"),nodeFiles:r((s,e)=>`imports/${s}/node-files/${e}.tar.zst`,"nodeFiles"),bodyRows:r((s,e)=>`imports/${s}/rows/bodies/${e}.jsonl.zst`,"bodyRows"),request:r((s,e)=>`requests/${s}/${e}`,"request")};function B(s,e,t){return e===h?(t.bodyParts??[]).map(o=>c.bodyRows(s,o)):[c.rows(s,e)]}r(B,"rowKeys");function L(s,e){let t;for(const o of s)(e===o.from||e.startsWith(o.from.endsWith("/")?o.from:`${o.from}/`))&&(t===void 0||o.from.length>t.from.length)&&(t=o);return t===void 0?e:t.to+e.slice(t.from.length)}r(L,"mapPath");function j(s){let e="";for(const t of s)e+=`${JSON.stringify(t)}
+`;return l(Buffer.from(e,"utf8"))}r(j,"encodeRows");function A(s){const e=_(s).toString("utf8");if(e==="")return[];if(!e.endsWith(`
+`))throw new Error("row file is truncated: the last line is not newline-terminated");return e.slice(0,-1).split(`
+`).map(t=>JSON.parse(t))}r(A,"decodeRows");function D(s){return`${JSON.stringify(s)}
+`}r(D,"rowLine");class O{static{r(this,"RowFileWriter")}zst=m();finished;written=0;constructor(e){this.finished=f(this.zst,u(e)),this.finished.catch(()=>{})}get bytes(){return this.written}async write(e,t=Buffer.byteLength(e,"utf8")){this.written+=t,this.zst.write(e,"utf8")||await Promise.race([d(this.zst,"drain"),this.finished])}async close(){this.zst.end(),await this.finished}destroy(){this.zst.destroy()}}async function*P(s){const e=p({chunkSize:1048576});e.end(s);let t=[];for await(const o of e){let n=0;for(let i=o.indexOf(10,n);i!==-1;i=o.indexOf(10,n))t.push(o.subarray(n,i)),yield(t.length===1?t[0]:Buffer.concat(t)).toString("utf8"),t=[],n=i+1;n<o.length&&t.push(o.subarray(n))}if(t.length>0)throw new Error("row file is truncated: the last line is not newline-terminated")}r(P,"rowLines");export{h as BODIES_TABLE,w as COPIED_TABLES,E as DUMPED_TABLES,z as KEY_MAPPED_TABLES,O as RowFileWriter,$ as SEQ_TABLES,x as STAGED_ONLY_TABLES,c as bundleKeys,A as decodeRows,j as encodeRows,L as mapPath,B as rowKeys,D as rowLine,P as rowLines};

package/dist/core/import/export/archive.d.ts

@@ -0,0 +1,11 @@
+import type { PathPrefix } from '../bundle/layout.js';
+/** One node's archive and the directories in it: context dir, worktree, and a cwd outside both. The lane picks each directory's sandbox target. */
+export declare function nodeArchive(node: {
+    node: string;
+    app: string;
+    cwd: string;
+    worktree: string | null;
+}, contextDir?: string): Promise<{
+    data: Buffer;
+    prefixes: PathPrefix[];
+}>;

package/dist/core/import/export/archive.js

@@ -0,0 +1 @@
+var a=Object.defineProperty;var s=(r,c)=>a(r,"name",{value:c,configurable:!0});import{existsSync as n}from"node:fs";import{join as l}from"node:path";import{zstdCompressSync as u}from"node:zlib";import*as w from"tar";import{nodeAgentDir as h}from"../../canvas/paths.js";async function S(r,c=l(h(r.node,r.app),"context")){const e={node:r.node,app:r.app},t=[{...e,role:"context",from:c}];r.worktree!==null&&t.push({...e,role:"worktree",from:r.worktree});const f=t.some(o=>r.cwd===o.from||r.cwd.startsWith(`${o.from}/`));r.cwd!==""&&!f&&t.push({...e,role:"cwd",from:r.cwd});const i=[],p=w.create({cwd:"/",portable:!0,filter:s((o,m)=>!("isSymbolicLink"in m&&m.isSymbolicLink()),"filter")},t.filter(o=>n(o.from)).map(o=>o.from.replace(/^\//,"")));for await(const o of p)i.push(o);return{data:u(Buffer.concat(i)),prefixes:t}}s(S,"nodeArchive");export{S as nodeArchive};

package/dist/core/import/export/cloud.d.ts

@@ -0,0 +1,21 @@
+import type { ImportRunDTO, ImportStartRequest, ImportStartedDTO, ImportStoreNameDTO, ImportUploadUrlsDTO } from '../../../api/dto/imports.js';
+/** The dump directory's file holding the opened file stores, and the order they are uploaded in. */
+export declare const STORE_FILE = "stores.json";
+export declare const STORE_ORDER: readonly ImportStoreNameDTO[];
+export declare class ImportCloud {
+    private readonly apiUrl;
+    private readonly token;
+    constructor(apiUrl: string, token: string);
+    private call;
+    start(request: ImportStartRequest): Promise<ImportStartedDTO>;
+    uploadUrls(run: string, keys: string[]): Promise<ImportUploadUrlsDTO>;
+    putStore(run: string, name: ImportStoreNameDTO, body: unknown): Promise<void>;
+    load(run: string): Promise<ImportRunDTO>;
+    get(run: string): Promise<ImportRunDTO>;
+    machineCredential(run: string): Promise<{
+        environment_id: string;
+        credential: string;
+    }>;
+    /** PUT bytes to a signed URL. */
+    put(url: string, data: Buffer): Promise<void>;
+}

package/dist/core/import/export/cloud.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var i=(a,t)=>l(a,"name",{value:t,configurable:!0});import{general as o}from"../../errors.js";const u="stores.json",d=["auth","credentials","env","settings","plugins"];class h{static{i(this,"ImportCloud")}apiUrl;token;constructor(t,e){this.apiUrl=t,this.token=e}async call(t,e,r){const s=await fetch(new URL(e,this.apiUrl),{method:t,headers:{authorization:`Bearer ${this.token}`,...r===void 0?{}:{"content-type":"application/json"}},...r===void 0?{}:{body:JSON.stringify(r)}}),n=await s.text();if(!s.ok)throw o(`${t} ${e} answered ${s.status}: ${n.slice(0,500)}`);return n===""?void 0:JSON.parse(n)}start(t){return this.call("POST","/v1/imports",t)}uploadUrls(t,e){return this.call("POST",`/v1/imports/${t}/upload-urls`,{keys:e})}putStore(t,e,r){return this.call("PUT",`/v1/imports/${t}/stores/${e}`,r)}load(t){return this.call("POST",`/v1/imports/${t}/load`,{})}get(t){return this.call("GET",`/v1/imports/${t}`)}machineCredential(t){return this.call("POST",`/v1/imports/${t}/machine-credential`,{})}async put(t,e){const r=await fetch(t,{method:"PUT",body:new Uint8Array(e)});if(!r.ok)throw o(`upload answered ${r.status}: ${(await r.text()).slice(0,300)}`)}}export{h as ImportCloud,u as STORE_FILE,d as STORE_ORDER};

package/dist/core/import/export/dump.d.ts

@@ -0,0 +1,34 @@
+import { type SourceJson } from '../bundle/layout.js';
+export interface DumpRequestRef {
+    id: string;
+    dir: string;
+    file: string | null;
+}
+export interface DumpRunningNode {
+    node: string;
+    app: string;
+    cwd: string;
+    worktree: string | null;
+}
+export interface DumpResult {
+    source: SourceJson;
+    /** Human requests (page and review) with the folder and reviewed file their rows name. */
+    requests: DumpRequestRef[];
+    /** Nodes with status active or idle, for the hosted node-file archives. */
+    runningNodes: DumpRunningNode[];
+    /** `body_ref` files that could not be read and stayed as references. */
+    bodiesMissing: number;
+    bodiesInlined: number;
+}
+/** A `bodies` part file holds about this much JSON (the encoded lines, before compression); a row that alone exceeds it is a part of its own. */
+export declare const PART_JSON_BYTES: number;
+/** A body longer than this many UTF-8 bytes fails the export. The largest body on Silas's Mac is 5.2 MB. JSON escapes one character into at most six (`\u0001`), so a body at
+ *  the ceiling is a line of at most 192 MiB, well inside V8's ~512 MiB string limit. */
+export declare const BODY_MAX_BYTES: number;
+/** The pre-pause dump of `bodies` (design-import cutover step 2): every row, while nodes still run. Rows are never updated or deleted, so the pause dump
+ *  needs only the rows whose hash is not in the list this leaves in `<out>/bodies-pre.json`. */
+export declare function dumpBodiesPre(out: string): Promise<{
+    parts: string[];
+    count: number;
+}>;
+export declare function dumpRows(out: string, kind: SourceJson['kind']): Promise<DumpResult>;

package/dist/core/import/export/dump.js

@@ -0,0 +1,3 @@
+var G=Object.defineProperty;var s=(t,n)=>G(t,"name",{value:n,configurable:!0});import{mkdirSync as v,readFileSync as M,writeFileSync as k}from"node:fs";import{join as f}from"node:path";import{openDb as X,withCanvasWrite as K}from"../../canvas/db.js";import{hashOf as Q,storable as Z}from"../../graph/bodies.js";import{personIdAsync as ee}from"../../canvas/person.js";import{CANVAS_SCHEMA_VERSION as te}from"../../canvas/schema-version.js";import{crtrVersion as ne}from"../../../shared/crtr-version.js";import{BODIES_TABLE as x,DUMPED_TABLES as H,RowFileWriter as ae,SEQ_TABLES as re,bundleKeys as se,encodeRows as oe,rowLine as ie}from"../bundle/layout.js";import{parseFrontmatterGeneric as ce}from"../../frontmatter.js";import{inlineMessageBody as le}from"./inline.js";const he=16*1024*1024,pe=8*1024*1024,D=32*1024*1024,W=5e3,$="bodies-pre.json",F=s(t=>`"${t.replace(/"/g,'""')}"`,"q");function de(t){try{const n=M(t,"utf8");return n.trim()===""?null:n}catch(n){if(n.code==="ENOENT")return null;throw n}}s(de,"readText");function ue(t){try{return M(t,"utf8")}catch(n){if(n.code==="ENOENT")return null;throw n}}s(ue,"readFileOrNull");function P(t,n){return new Error(`revision text ${t} is ${n} bytes; the import carries at most ${D} bytes of text per body`)}s(P,"tooLarge");async function q(t,n,p,r,m){const w=f(n,"rows",x);v(w,{recursive:!0});const _=[];let o=null;const S=s(async()=>{const a=o;o=null,a!==null&&await a.close()},"close"),g=s(async a=>{const l=ie(a),i=Buffer.byteLength(l,"utf8");if(o!==null&&o.bytes>0&&o.bytes+i>he&&await S(),o===null){const h=`${p}-${_.length}`;o=new ae(f(w,`${h}.jsonl.zst`)),_.push(h)}await o.write(l,i)},"add");try{for(let a=0;a<r.length;){const l=await t.prepare("SELECT hash, octet_length(text) AS n FROM bodies WHERE hash = ANY(?::text[]) ORDER BY hash").all(r.slice(a,a+W));let i=[],h=0;const R=s(async()=>{if(i.length===0)return;const d=await t.prepare("SELECT hash, text FROM bodies WHERE hash = ANY(?::text[]) ORDER BY hash").all(i);for(const O of d)await g(O);i=[],h=0},"fetchPage");for(const{hash:d,n:O}of l){const E=Number(O);if(E>D)throw P(d,E);i.length>0&&h+E>pe&&await R(),i.push(d),h+=E}await R(),a+=W}for(const a of m){const l=Buffer.byteLength(a.text,"utf8");if(l>D)throw P(a.hash,l);await g(a)}await S()}catch(a){throw o?.destroy(),a}return _}s(q,"writeBodyParts");const J=s(async t=>(await t.prepare("SELECT hash FROM bodies ORDER BY hash").all()).map(n=>n.hash),"allHashes");async function Ne(t){const n=await X(),p=await J(n),r=await q(n,t,"pre",p,[]),m={hashes:p,parts:r,count:p.length};return k(f(t,$),JSON.stringify(m)),{parts:r,count:p.length}}s(Ne,"dumpBodiesPre");function Ee(t){try{return JSON.parse(M(f(t,$),"utf8"))}catch(n){if(n.code==="ENOENT")return{hashes:[],parts:[],count:0};throw n}}s(Ee,"readPre");async function Le(t,n){const p=await ee();return v(f(t,"rows"),{recursive:!0}),K(async r=>{await r.exec("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ");const m=new Set((await r.prepareUncached("SELECT table_name FROM information_schema.tables WHERE table_schema = current_schema()").all()).map(e=>e.table_name)),w=H.filter(e=>!m.has(e));if(w.length>0)throw new Error(`the canvas database lacks tables the bundle needs: ${w.join(", ")}`);const _=await r.prepareUncached(`SELECT c.conrelid::regclass::text AS tbl, (SELECT array_agg(a.attname::text ORDER BY k.ord) FROM unnest(c.conkey) WITH ORDINALITY k(attnum, ord)
+        JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols FROM pg_constraint c WHERE c.contype = 'p' AND c.connamespace = current_schema()::regnamespace`).all(),o=new Map(_.map(e=>[e.tbl.replace(/"/g,"").replace(/^.*\./,""),e.cols])),S=await r.prepareUncached("SELECT table_name, column_name FROM information_schema.columns WHERE table_schema = current_schema() ORDER BY table_name, ordinal_position").all(),g=new Set(re),a={};let l=0,i=0;for(const e of H.filter(u=>u!==x)){const u=g.has(e)?["seq"]:o.get(e),y=u!==void 0&&u.length>0?u.map(c=>`t.${F(c)}`):S.filter(c=>c.table_name===e).map(c=>`t.${F(c.column_name)}::text`);if(y.length===0)throw new Error(`table ${e} has no columns to order its dump by`);let T=(await r.prepareUncached(`SELECT row_to_json(t)::text AS j FROM ${F(e)} t ORDER BY ${y.join(", ")}`).all()).map(c=>JSON.parse(c.j));e==="messages"&&(T=T.map(c=>{const Y=c.body_ref,j=le(c,de);return typeof Y=="string"&&Y.startsWith("/")&&(j===c?i+=1:l+=1),j})),a[e]=T.length,k(f(t,se.rows("",e).replace(/^imports\/\//,"")),oe(T))}const h=(await r.prepare("SELECT value FROM canvas_meta WHERE key = 'install_id'").get())?.value;if(h===void 0)throw new Error("this canvas database has no install id");const R=await r.prepare("SELECT object FROM environments WHERE kind = 'machine' ORDER BY object LIMIT 1").get(),d={installId:h,kind:n,person:p,release:ne(),schemaVersion:te,counts:a,...R===void 0?{}:{environmentObject:R.object}},O=await r.prepare("SELECT request_id, request_dir, file FROM human_requests ORDER BY request_id").all(),E=await r.prepare("SELECT object, source_path FROM documents WHERE source_path IS NOT NULL ORDER BY object").all(),I={},N=new Map;for(const e of E){const u=ue(e.source_path);if(u===null)continue;const y=Z(ce(u).body),b=Q(y);I[e.object]=b,N.set(b,{hash:b,text:y})}const L=Ee(t),A=new Set(L.hashes),B=(await J(r)).filter(e=>!A.has(e)),C=new Set(B),U=await q(r,t,"pause",B,[...N.values()].filter(e=>!A.has(e.hash)&&!C.has(e.hash))),V=L.count+B.length+[...N.values()].filter(e=>!A.has(e.hash)&&!C.has(e.hash)).length;a[x]=V,d.bodyParts=[...L.parts,...U];const z=await r.prepare(`SELECT n.node_id, r.grantee, n.cwd, w.path AS worktree FROM nodes n JOIN node_rows r ON r.node_id = n.node_id LEFT JOIN worktrees w ON w.node_id = n.node_id AND w.state = 'open'
+      WHERE n.status IN ('active', 'idle') ORDER BY n.node_id`).all();return d.shippedBodies=I,{source:d,requests:O.map(e=>({id:e.request_id,dir:e.request_dir,file:e.file})),runningNodes:z.map(e=>({node:e.node_id,app:e.grantee,cwd:e.cwd,worktree:e.worktree})),bodiesInlined:l,bodiesMissing:i}})}s(Le,"dumpRows");export{D as BODY_MAX_BYTES,he as PART_JSON_BYTES,Ne as dumpBodiesPre,Le as dumpRows};

package/dist/core/import/export/files.d.ts

@@ -0,0 +1,22 @@
+import type { ImportCloud } from './cloud.js';
+export interface LocalObject {
+    key: string;
+    path: string;
+}
+/** Every file the runtime holds that the cloud serves from a blob key. */
+export declare function localObjects(): LocalObject[];
+/** The reviewed file of a review that lies outside the review's own directory, at the key the lane rewrites `file` to. */
+export declare function reviewSourceObject(requestId: string, requestDir: string, file: string | null): LocalObject | null;
+export declare class Uploader {
+    private readonly cloud;
+    private readonly run;
+    private readonly progress;
+    private readonly sent;
+    uploaded: number;
+    missing: string[];
+    constructor(cloud: ImportCloud, run: string, progress: (line: string) => void);
+    /** Upload source blobs, each to `imports/<run>/blobs/<its key>`: the upload route signs only under the run's own prefix, and the lane moves each blob to its key. */
+    upload(objects: readonly LocalObject[]): Promise<void>;
+    /** Upload bytes held in memory (row files, source.json, node archives). */
+    uploadBytes(key: string, data: Buffer): Promise<void>;
+}

package/dist/core/import/export/files.js

@@ -0,0 +1 @@
+var f=Object.defineProperty;var a=(s,o)=>f(s,"name",{value:o,configurable:!0});import{readFileSync as y,readdirSync as w,statSync as g}from"node:fs";import{basename as b,join as l,relative as k,sep as $}from"node:path";import{runtimeRoot as j}from"../../layout.js";import{bundleKeys as p}from"../bundle/layout.js";import{runBlobKey as d}from"../bundle/blob-keys.js";function c(s,o,t=s){let r;try{r=w(s,{withFileTypes:!0})}catch(e){if(e.code==="ENOENT")return;throw e}for(const e of r){const n=l(s,e.name);e.isDirectory()?c(n,o,t):e.isFile()&&!e.name.endsWith(".tmp")&&!e.name.includes(".tmp-")&&o(n,k(t,n).split($).join("/"))}}a(c,"walk");function S(){const s=j(),o=[];c(l(s,"blobs"),(t,r)=>o.push({key:r,path:t}));for(const t of["requests","reviews"])c(l(s,t),(r,e)=>{const[n,...u]=e.split("/");u.length>0&&o.push({key:p.request(n,u.join("/")),path:r})});return o}a(S,"localObjects");function W(s,o,t){return t===null||!t.startsWith("/")||t.startsWith(o.endsWith("/")?o:`${o}/`)?null:{key:p.request(s,`source/${b(t)}`),path:t}}a(W,"reviewSourceObject");class F{static{a(this,"Uploader")}cloud;run;progress;sent=new Map;uploaded=0;missing=[];constructor(o,t,r){this.cloud=o,this.run=t,this.progress=r}async upload(o){const t=[];for(const r of o){let e;try{e=g(r.path)}catch(u){if(u.code==="ENOENT"){this.missing.push(r.path);continue}throw u}const n=`${e.size}:${e.mtimeMs}`;this.sent.get(r.key)!==n&&t.push({...r,stamp:n})}for(let r=0;r<t.length;r+=100){const e=t.slice(r,r+100),{urls:n}=await this.cloud.uploadUrls(this.run,e.map(i=>d(this.run,i.key)));let u=0;const m=a(async()=>{for(let i=e[u++];i!==void 0;i=e[u++]){const h=n[d(this.run,i.key)];if(h===void 0)throw new Error(`no upload URL returned for ${i.key}`);await this.cloud.put(h,y(i.path)),this.sent.set(i.key,i.stamp),this.uploaded+=1}},"worker");await Promise.all(Array.from({length:Math.min(8,e.length)},m)),this.progress(`uploaded ${Math.min(r+100,t.length)}/${t.length}`)}}async uploadBytes(o,t){const{urls:r}=await this.cloud.uploadUrls(this.run,[o]),e=r[o];if(e===void 0)throw new Error(`no upload URL returned for ${o}`);await this.cloud.put(e,t)}}export{F as Uploader,S as localObjects,W as reviewSourceObject};

package/dist/core/import/export/inline.d.ts

@@ -0,0 +1,3 @@
+import type { RowObject } from '../bundle/layout.js';
+/** `read` returns the file's text, or null when the file is absent or empty. */
+export declare function inlineMessageBody(row: RowObject, read: (path: string) => string | null): RowObject;

package/dist/core/import/export/inline.js

@@ -0,0 +1 @@
+var f=Object.defineProperty;var r=(t,e)=>f(t,"name",{value:e,configurable:!0});function i(t,e){const o=t.body_ref;if(typeof o!="string"||!o.startsWith("/"))return t;const s=e(o);if(s===null)return t;const n=t.body_json,y=n!==null&&typeof n=="object"&&!Array.isArray(n)?n:{};return{...t,body_ref:null,body_json:{...y,body_full:s}}}r(i,"inlineMessageBody");export{i as inlineMessageBody};

package/dist/core/import/export/source.d.ts

@@ -0,0 +1,2 @@
+import type { PathPrefix, SourceJson } from '../bundle/layout.js';
+export declare function buildSourceJson(dump: SourceJson, prefixes: readonly PathPrefix[]): SourceJson;

package/dist/core/import/export/source.js

@@ -0,0 +1 @@
+var o=Object.defineProperty;var e=(t,n)=>o(t,"name",{value:n,configurable:!0});function u(t,n){return{...t,...n.length>0?{pathPrefixes:[...n]}:{}}}e(u,"buildSourceJson");export{u as buildSourceJson};

package/dist/core/import/export/stores.d.ts

@@ -0,0 +1,9 @@
+import type { ImportAuthStoreDTO, ImportCredentialsStoreDTO, ImportEnvStoreDTO, ImportPluginsStoreDTO, ImportSettingsStoreDTO } from '../../../api/dto/imports.js';
+export interface ExportedStores {
+    auth: ImportAuthStoreDTO;
+    credentials: ImportCredentialsStoreDTO;
+    env: ImportEnvStoreDTO;
+    settings: ImportSettingsStoreDTO;
+    plugins: ImportPluginsStoreDTO;
+}
+export declare function readStores(): Promise<ExportedStores>;

package/dist/core/import/export/stores.js

@@ -0,0 +1 @@
+var k=Object.defineProperty;var _=(a,t)=>k(a,"name",{value:t,configurable:!0});import{openDb as R}from"../../canvas/db.js";import{personIdAsync as h}from"../../canvas/person.js";import{loadSecretsKey as y,open as c}from"../../secrets/index.js";import{aadOf as v}from"../../subscription-state.js";import{aadOf as O}from"../../secrets/env-rows.js";const r=_(a=>a==null?null:String(a),"str"),o=_(a=>Number(a??0),"num");async function M(){const a=await h(),t=await R(),d=y(),u={};for(const e of await t.prepare("SELECT provider_id, credential_sealed, key_id FROM model_api_keys WHERE person = ? ORDER BY provider_id").all(a)){const n=String(e.provider_id);u[n]=JSON.parse(c(e.credential_sealed,String(e.key_id),d,`model_api_keys|${a}|${n}`))}const w=await t.prepare("SELECT provider_id, account_id, family, rate_limited_until, last_rate_limited_at FROM model_account_cooldowns WHERE person = ? ORDER BY family").all(a),E=[];for(const e of await t.prepare("SELECT * FROM model_accounts WHERE person = ? ORDER BY provider_id, position").all(a)){const n=String(e.provider_id),l=String(e.id);if(e.refresh_sealed===null||e.access_sealed===null||e.key_id===null)throw new Error(`managed ${n} account ${l} has no credential record`);const g=String(e.key_id);E.push({provider:n,id:l,label:String(e.label),labelKey:String(e.label_key),position:o(e.position),lastAttemptAt:o(e.last_attempt_at),lastRateLimitedAt:o(e.last_rate_limited_at),rateLimitedUntil:o(e.rate_limited_until),...e.auth_failure==="invalid_grant"?{authFailure:"invalid_grant"}:{},refresh:c(e.refresh_sealed,g,d,v(a,n,l,"refresh")),access:c(e.access_sealed,g,d,v(a,n,l,"access")),expires:o(e.expires),...r(e.vendor_account_id)===null?{}:{accountId:r(e.vendor_account_id)},...r(e.client_id)===null?{}:{clientId:r(e.client_id)},cooldowns:w.filter(s=>s.provider_id===n&&s.account_id===l).map(s=>({family:String(s.family),until:o(s.rate_limited_until),at:o(s.last_rate_limited_at)}))})}const i=await t.prepare("SELECT default_fallback_strength, revert_when_available, openai_device_id FROM model_settings WHERE person = ?").get(a),S={accounts:E,...i===void 0||i.default_fallback_strength===null&&i.revert_when_available===null?{}:{rotation:{defaultFallbackStrength:r(i.default_fallback_strength),revertWhenAvailable:i.revert_when_available===null?null:o(i.revert_when_available)===1}},...i===void 0||r(i.openai_device_id)===null?{}:{openaiDeviceId:r(i.openai_device_id)}},m={};for(const e of await t.prepare("SELECT owner_id, name, value_sealed, key_id FROM env_vars WHERE person = ? AND owner_kind = 'profile' ORDER BY owner_id, name").all(a)){const n=String(e.owner_id),l=String(e.name);(m[n]??={})[l]=c(e.value_sealed,String(e.key_id),d,O({person:a,kind:"profile",id:n},l))}const p={settings:{},state:{},profileProjects:{},defaults:{}};for(const e of await t.prepare("SELECT owner_key, raw_json FROM scope_settings WHERE person = ?").all(a))p.settings[String(e.owner_key)]=JSON.parse(String(e.raw_json));for(const e of await t.prepare("SELECT owner_key, last_self_check, active_canvas FROM scope_bookkeeping WHERE person = ?").all(a))p.state[String(e.owner_key)]={last_self_check:r(e.last_self_check),activeCanvas:r(e.active_canvas)};for(const e of await t.prepare("SELECT pp.profile_id, pp.path FROM profile_projects pp JOIN profiles p ON p.id = pp.profile_id WHERE p.person = ? ORDER BY pp.profile_id, pp.position").all(a))(p.profileProjects[String(e.profile_id)]??=[]).push(String(e.path));for(const e of await t.prepare("SELECT directory, profile_id FROM profile_defaults WHERE person = ?").all(a))p.defaults[String(e.directory)]=String(e.profile_id);const f={marketplaces:[],plugins:[]};for(const e of await t.prepare("SELECT * FROM scope_marketplaces WHERE person = ? ORDER BY owner_key, name").all(a))f.marketplaces.push({owner:String(e.owner_key),name:String(e.name),url:r(e.url),ref:r(e.ref),installed_at:r(e.installed_at),last_updated:r(e.last_updated)});for(const e of await t.prepare("SELECT * FROM scope_plugins WHERE person = ? ORDER BY owner_key, name").all(a))f.plugins.push({owner:String(e.owner_key),name:String(e.name),enabled:o(e.enabled)===1,source_marketplace:r(e.source_marketplace),version:r(e.version),source_path:r(e.source_path),last_updated:r(e.last_updated),etag:r(e.etag),checked_at:r(e.checked_at)});return{auth:{apiKeys:u},credentials:S,env:{profiles:m},settings:p,plugins:f}}_(M,"readStores");export{M as readStores};

package/dist/core/import/load/bind.d.ts

@@ -0,0 +1,19 @@
+import type { CanvasDb } from '../../canvas/db.js';
+import { type RewriteInput } from './rewrite.js';
+/** A grant's or row's `sub` as the run sees it: the source's person is the run's, no other person is allowed. */
+export declare function boundSub(sub: string, source: string, run: string, where: string): string;
+/** Before anything is staged: the bundle's person has the shape of a person, and when it differs from the run's it is not already someone else in the target. */
+export declare function checkSourcePerson(db: CanvasDb, target: string, source: string, run: string): Promise<void>;
+/** After staging, before rewrite 1: every person the staged rows name is the bundle's or the run's. Drops the directory's own team facts
+ *  (`crtr/group` relations). Returns rows dropped per table. */
+export declare function checkStagedPersons(input: RewriteInput): Promise<Record<string, number>>;
+/** After rewrite 2 and the drop: every reference from a staged row to a target row reaches a row the run's person owns or acts for (an app, a shipped
+ *  document, the person's own object, an object with an `acts_for` fact for the person, or anything below those that is not directly under an app), and no profile or grant the
+ *  rows name belongs to another person. */
+export declare function checkStagedReferences(input: RewriteInput): Promise<void>;
+/** After staging, before rewrite 1: every blob key a staged row names has the shape its row would produce and an owner (node) that is in this bundle.
+ *  A key naming another person's blob is `person_mismatch`; a key of no known shape is `bundle_invalid`. Without this, the importer's own node would read, and
+ *  compaction would delete, a blob of someone else's conversation. (Human requests are checked by `checkStagedRequestKeys`, after their dirs are rewritten to blob keys.) */
+export declare function checkStagedBlobKeys(input: RewriteInput): Promise<void>;
+/** After rewrite 4b: a human request's `request_dir`, `presentation_dir` and `file` that are blob keys (`requests/…`) are under the request's own `requests/<its id>`. */
+export declare function checkStagedRequestKeys(input: RewriteInput): Promise<void>;

package/dist/core/import/load/bind.js

@@ -0,0 +1,15 @@
+var g=Object.defineProperty;var u=(s,t)=>g(s,"name",{value:t,configurable:!0});import{parseBlobKey as L}from"../bundle/blob-keys.js";import{q as E}from"./catalog.js";import{objectIdColumns as R}from"./rewrite.js";import{ImportLaneError as m}from"./stage.js";const w=/^user:[A-Za-z0-9._-]+$/,S=u(s=>s.replace(/^user:/,""),"bare"),I=u((s,t)=>`${E(s)}.${E(t)}`,"sq"),$=u(async(s,t,...r)=>await s.prepareUncached(t).all(...r),"all");function _(s,t){return new m("bind","person_mismatch",s,t)}u(_,"mismatch");function D(s,t,r,a){if(s===t||s===r)return r;throw _(`${a} names ${s}, which is neither the bundle's person nor the importing person`,{where:a,value:s})}u(D,"boundSub");async function k(s,t,r,a){if(!w.test(r))throw _(`the bundle's person ${JSON.stringify(r)} is not a user:<id> principal`,{where:"source.json person",value:r});if(r===a)return;const i=u(e=>I(t,e),"T"),n=await s.prepareUncached(`SELECT 'identities' AS tbl FROM ${i("identities")} WHERE scheme IN ('user', 'local-user') AND external_id = ?
+    UNION ALL SELECT 'grants' FROM ${i("grants")} WHERE sub = ? UNION ALL SELECT 'profiles' FROM ${i("profiles")} WHERE person = ?
+    UNION ALL SELECT 'nodes' FROM ${i("nodes")} WHERE sub = ? LIMIT 1`).get(r,r,r,r);if(n!==void 0)throw _(`the bundle's person ${r} is already a person in the target (${n.tbl}), not the importing person ${a}`,{where:`${n.tbl}`,value:r})}u(k,"checkSourcePerson");const v=[["nodes","sub"],["crons","sub"],["grants","sub"],["profiles","person"],["charges","sub"],["limits","sub"],["audit_rows","sub"],["provider_approvals","sub"]],C=[["charges","payer"],["limits","payer"],["audit_rows","payer"],["audit_rows","grantee"],["charges","grantee"],["run_events","grantee"],["idempotency_keys","grantee"],["uploads","grantee"],["provider_approvals","grantee"],["profiles","grantee"],["crons","grantee"]];async function H(s){const{db:t,schema:r,sourcePerson:a,targetPerson:i}=s,n=u(p=>I(r,p),"S"),e=u((p,d)=>{throw _(`${p} names ${d.join(", ")}, who is neither the bundle's person ${a} nor the importing person ${i}`,{where:p,values:d})},"refuse");for(const[p,d]of v){const o=await $(t,`SELECT DISTINCT ${E(d)} AS v FROM ${n(p)} WHERE ${E(d)} IS NOT NULL AND ${E(d)} <> '' AND ${E(d)} NOT IN (?, ?) LIMIT 5`,a,i);o.length>0&&e(`${p}.${d}`,o.map(l=>l.v))}for(const[p,d]of C){const o=await $(t,`SELECT DISTINCT ${E(d)} AS v FROM ${n(p)} WHERE ${E(d)} LIKE 'user:%' AND ${E(d)} NOT IN (?, ?) LIMIT 5`,a,i);o.length>0&&e(`${p}.${d}`,o.map(l=>l.v))}const c=await $(t,`SELECT DISTINCT external_id AS v FROM ${n("identities")} WHERE scheme IN ('user', 'local-user') AND external_id NOT IN (?, ?) LIMIT 5`,a,i);c.length>0&&e("identities.external_id",c.map(p=>p.v));const f=await $(t,`SELECT DISTINCT adapter_json::jsonb #>> '{principal,sub}' AS v FROM ${n("daemon_actions")}
+    WHERE adapter_json::jsonb #>> '{principal,sub}' IS NOT NULL AND adapter_json::jsonb #>> '{principal,sub}' NOT IN (?, ?) LIMIT 5`,a,i);f.length>0&&e("daemon_actions principal.sub",f.map(p=>p.v));const h=await $(t,`SELECT DISTINCT subject_id AS v FROM ${n("relations")} WHERE relation = 'acts_for' AND subject_type = 'user' AND subject_id NOT IN (?, ?) LIMIT 5`,S(a),S(i));h.length>0&&e("relations acts_for subject",h.map(p=>p.v));const N=Number((await t.prepareUncached(`DELETE FROM ${n("relations")} WHERE resource_type = 'crtr/group'`).run()).changes);return N>0?{relations:N}:{}}u(H,"checkStagedPersons");async function W(s){const{db:t,schema:r,target:a,catalog:i,targetPerson:n}=s,e=u(o=>I(r,o),"S"),c=u(o=>I(a,o),"T"),f=S(n);await t.exec(`CREATE TABLE ${e("_refs")} (tbl text NOT NULL, col text NOT NULL, value text NOT NULL)`);const h=[];for(const[o,l]of R(i))if(!(!i.tables.has(o)||o==="relations"))for(const b of l)!(o==="nodes"&&b==="profile_id")&&!(o==="crons"&&b==="profile")&&h.push([o,b,""]);h.push(["relations","resource_id","WHERE resource_type = 'crtr/object'"]);for(const[o,l,b]of h)await t.prepareUncached(`INSERT INTO ${e("_refs")} SELECT ?, ?, ${E(l)}::text FROM ${e(o)} ${b===""?"WHERE":`${b} AND`} ${E(l)} IS NOT NULL
+      AND ${E(l)}::text NOT IN (SELECT id FROM ${e("objects")}) AND ${E(l)}::text IN (SELECT id FROM ${c("objects")})`).run(o,l);const N=await $(t,`WITH RECURSIVE chain(start, id) AS (
+      SELECT DISTINCT value, value FROM ${e("_refs")}
+      UNION SELECT c.start, o.owner FROM chain c JOIN ${c("objects")} o ON o.id = c.id JOIN ${c("objects")} up ON up.id = o.owner AND up.type <> 'app'),
+    ok(id) AS (
+      SELECT o.id FROM ${c("objects")} o WHERE o.type = 'app'
+      UNION SELECT d.object FROM ${c("documents")} d WHERE d.source_path IS NOT NULL
+      UNION SELECT i.object FROM ${c("identities")} i WHERE i.scheme IN ('user', 'local-user') AND i.external_id = ?
+      UNION SELECT r.resource_id FROM ${c("relations")} r WHERE r.resource_type = 'crtr/object' AND r.relation = 'acts_for' AND r.subject_type = 'user' AND r.subject_id = ?)
+    SELECT r.tbl, r.col, r.value FROM ${e("_refs")} r
+      WHERE NOT EXISTS (SELECT 1 FROM chain c JOIN ok ON ok.id = c.id WHERE c.start = r.value) LIMIT 10`,n,f);if(N.length>0)throw _(`the bundle refers to objects that are not ${n}'s: ${N.map(o=>`${o.tbl}.${o.col}=${o.value}`).join(", ")}`,{references:N});const p=[["nodes","profile_id"],["crons","profile"],["profiles","id"]];for(const[o,l]of p){const b=await $(t,`SELECT DISTINCT s.${E(l)} AS v FROM ${e(o)} s JOIN ${c("profiles")} p ON p.id = s.${E(l)} WHERE p.person <> ? LIMIT 5`,n);if(b.length>0)throw _(`${o}.${l} names profiles that belong to another person: ${b.map(T=>T.v).join(", ")}`,{where:`${o}.${l}`,values:b.map(T=>T.v)})}for(const[o,l]of[["nodes","grant_id"],["crons","grant_id"]]){const b=await $(t,`SELECT DISTINCT s.${E(l)} AS v FROM ${e(o)} s JOIN ${c("grants")} g ON g.id = s.${E(l)} WHERE g.sub <> ? LIMIT 5`,n);if(b.length>0)throw _(`${o}.${l} names grants that belong to another person: ${b.map(T=>T.v).join(", ")}`,{where:`${o}.${l}`,values:b.map(T=>T.v)})}const d=await $(t,`SELECT DISTINCT d.adapter_json::jsonb #>> '{principal,grant_id}' AS v FROM ${e("daemon_actions")} d
+    JOIN ${c("grants")} g ON g.id = d.adapter_json::jsonb #>> '{principal,grant_id}' WHERE g.sub <> ? LIMIT 5`,n);if(d.length>0)throw _(`a queued action names grants that belong to another person: ${d.map(o=>o.v).join(", ")}`,{where:"daemon_actions principal.grant_id",values:d.map(o=>o.v)})}u(W,"checkStagedReferences");const O=u((s,t)=>new m("bind","bundle_invalid",s,t),"bundleInvalid");async function U(s){const{db:t,schema:r}=s,a=u(e=>I(r,e),"S"),i=new Set((await $(t,`SELECT node_id AS v FROM ${a("nodes")}`)).map(e=>e.v)),n=u((e,c,f,h)=>{const N=L(c);if(N===null||N.kind!==f||h!==void 0&&c!==h)throw O(`${e} holds ${JSON.stringify(c)}, which is not a ${f} blob key${h===void 0?"":` of the shape ${h}`}`,{where:e,value:c});if(!i.has(N.owner))throw _(`${e} holds ${c}, which belongs to node ${N.owner}, who is not in the bundle`,{where:e,value:c})},"check");for(const e of await $(t,`SELECT conversation_id, seq::text AS seq, blob_key FROM ${a("conversation_parts")}`))if(n("conversation_parts.blob_key",e.blob_key,"conversation"),e.blob_key.split("/")[2]!==e.conversation_id)throw O(`conversation_parts.blob_key ${e.blob_key} is not under its conversation ${e.conversation_id}`,{where:"conversation_parts.blob_key",value:e.blob_key});for(const e of await $(t,`SELECT blob_key FROM ${a("upload_uses")} WHERE blob_key IS NOT NULL`))n("upload_uses.blob_key",e.blob_key,"attachment");for(const e of await $(t,`SELECT object, output_key FROM ${a("jobs")} WHERE output_key IS NOT NULL`)){const c=e.output_key.split("/")[1]??"";n("jobs.output_key",e.output_key,"job",`jobs/${c}/${e.object}/output`)}}u(U,"checkStagedBlobKeys");async function q(s){const{db:t,schema:r}=s;for(const a of await $(t,`SELECT request_id, request_dir, presentation_dir, file FROM ${I(r,"human_requests")}`))for(const i of["request_dir","presentation_dir","file"]){const n=a[i];if(n===null||!n.startsWith("requests/"))continue;const e=L(n.includes("/",9)?n:`${n}/x`);if(e===null||e.kind!=="request")throw O(`human_requests.${i} holds ${JSON.stringify(n)}, which is not a request blob key`,{where:`human_requests.${i}`,value:n});if(e.owner!==a.request_id)throw _(`human_requests.${i} of ${a.request_id} holds ${n}, which belongs to request ${e.owner}`,{where:`human_requests.${i}`,value:n})}}u(q,"checkStagedRequestKeys");export{D as boundSub,k as checkSourcePerson,U as checkStagedBlobKeys,H as checkStagedPersons,W as checkStagedReferences,q as checkStagedRequestKeys};

package/dist/core/import/load/blobs.d.ts

@@ -0,0 +1,10 @@
+import type { BlobStore } from '../../blobs/index.js';
+import type { CanvasDb } from '../../canvas/db.js';
+export interface MovedBlobs {
+    moved: number;
+    left: number;
+}
+/** `created` collects the keys this call wrote, so the caller can delete them if the run fails before its copy commits. */
+export declare function moveRunBlobs(db: CanvasDb, schema: string, blobs: BlobStore, runId: string, created: string[]): Promise<MovedBlobs>;
+/** Delete the run's uploaded copies (after the run is done). */
+export declare function deleteRunBlobs(blobs: BlobStore, runId: string): Promise<void>;

package/dist/core/import/load/blobs.js

@@ -0,0 +1 @@
+var S=Object.defineProperty;var r=(e,n)=>S(e,"name",{value:n,configurable:!0});import{parseBlobKey as q,runBlobPrefix as f}from"../bundle/blob-keys.js";import{q as m}from"./catalog.js";import{ImportLaneError as h}from"./stage.js";const E=8;async function k(e,n,o,g,y){const v={nodes:new Set((await e.prepareUncached(`SELECT node_id AS v FROM ${m(n)}.nodes`).all()).map(t=>t.v)),human_requests:new Set((await e.prepareUncached(`SELECT request_id AS v FROM ${m(n)}.human_requests`).all()).map(t=>t.v))},w=f(g),s=await o.list(w),i={moved:0,left:0};let p=0;const x=r(async()=>{for(let t=p++;t<s.length;t=p++){const l=s[t],a=l.slice(w.length),c=q(a);if(c===null||!v[c.ownerTable].has(c.owner)){i.left+=1;continue}const u=await o.get(l);if(u===null)throw new h("blobs","bundle_invalid",`${l} was listed and is gone`);const d=await o.get(a);if(d===null)await o.put(a,u),y.push(a);else if(!d.equals(u))throw new h("blobs","unique_conflict",`${a} already exists with other contents; the import does not replace it`,{key:a});i.moved+=1}},"worker");return await Promise.all(Array.from({length:Math.min(E,s.length)},x)),i}r(k,"moveRunBlobs");async function A(e,n){for(const o of await e.list(f(n)))await e.delete(o)}r(A,"deleteRunBlobs");export{A as deleteRunBlobs,k as moveRunBlobs};

package/dist/core/import/load/catalog.d.ts

@@ -0,0 +1,32 @@
+import type { CanvasDb } from '../../canvas/db.js';
+export interface ForeignKey {
+    table: string;
+    columns: string[];
+    parent: string;
+    parentColumns: string[];
+}
+export interface UniqueKey {
+    table: string;
+    name: string;
+    columns: string[];
+    predicate: string | null;
+}
+/** The columns that identify a row of `info`: its primary key, or every column in order for a table with none (`memory_reads`). */
+export declare const rowKey: (info: TableInfo) => string[];
+export interface TableInfo {
+    name: string;
+    columns: string[];
+    primaryKey: string[];
+    identity: string[];
+}
+export interface Catalog {
+    schema: string;
+    tables: Map<string, TableInfo>;
+    foreignKeys: ForeignKey[];
+    uniqueKeys: UniqueKey[];
+}
+export declare const q: (name: string) => string;
+/** Read the catalog of `schema` for `tables`. */
+export declare function readCatalog(db: CanvasDb, schema: string, tables: readonly string[]): Promise<Catalog>;
+/** Parents before children. Cycles (none in the schema today) are broken by the table list's order. */
+export declare function topologicalOrder(catalog: Catalog, tables: readonly string[]): string[];

package/dist/core/import/load/catalog.js

@@ -0,0 +1,9 @@
+var g=Object.defineProperty;var r=(a,n)=>g(a,"name",{value:n,configurable:!0});const x=r(a=>a.primaryKey.length>0?a.primaryKey:a.columns,"rowKey"),y=r(a=>`"${a.replace(/"/g,'""')}"`,"q");async function O(a,n,p){const i=[...p],d=await a.prepareUncached(`SELECT table_name, column_name, is_identity FROM information_schema.columns
+    WHERE table_schema = ? AND table_name = ANY(?::text[]) ORDER BY table_name, ordinal_position`).all(n,`{${i.map(e=>`"${e}"`).join(",")}}`),o=new Map;for(const e of i)o.set(e,{name:e,columns:[],primaryKey:[],identity:[]});for(const e of d){const s=o.get(e.table_name);s.columns.push(e.column_name),e.is_identity==="YES"&&s.identity.push(e.column_name)}const l=await a.prepareUncached(`SELECT c.conrelid::regclass::text AS tbl, c.contype, c.conname,
+      (SELECT array_agg(a.attname::text ORDER BY k.ord) FROM unnest(c.conkey) WITH ORDINALITY k(attnum, ord) JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols,
+      c.confrelid::regclass::text AS ptbl,
+      (SELECT array_agg(a.attname::text ORDER BY k.ord) FROM unnest(c.confkey) WITH ORDINALITY k(attnum, ord) JOIN pg_attribute a ON a.attrelid = c.confrelid AND a.attnum = k.attnum) AS pcols
+    FROM pg_constraint c WHERE c.connamespace = ?::regnamespace AND c.contype IN ('p', 'f')`).all(n),c=r(e=>e.replace(/^.*\./,"").replace(/"/g,""),"bare"),t=[];for(const e of l){const s=c(e.tbl);o.has(s)&&(e.contype==="p"?o.get(s).primaryKey=e.cols:o.has(c(e.ptbl))&&t.push({table:s,columns:e.cols,parent:c(e.ptbl),parentColumns:e.pcols}))}const u=(await a.prepareUncached(`SELECT t.relname AS tbl, i.relname AS name, pg_get_expr(x.indpred, x.indrelid) AS predicate, x.indexprs IS NOT NULL AS has_expr,
+      (SELECT array_agg(a.attname::text ORDER BY k.ord) FROM unnest(x.indkey::int2[]) WITH ORDINALITY k(attnum, ord) JOIN pg_attribute a ON a.attrelid = x.indrelid AND a.attnum = k.attnum) AS cols
+    FROM pg_index x JOIN pg_class t ON t.oid = x.indrelid JOIN pg_class i ON i.oid = x.indexrelid
+    WHERE t.relnamespace = ?::regnamespace AND x.indisunique AND NOT x.indisprimary`).all(n)).filter(e=>o.has(e.tbl)&&!e.has_expr).map(e=>({table:e.tbl,name:e.name,columns:e.cols,predicate:e.predicate}));return{schema:n,tables:o,foreignKeys:t,uniqueKeys:u}}r(O,"readCatalog");function _(a,n){const p=new Set(n),i=new Map(n.map(t=>[t,new Set]));for(const t of a.foreignKeys)p.has(t.table)&&p.has(t.parent)&&t.table!==t.parent&&i.get(t.table).add(t.parent);const d=[],o=new Set,l=new Set,c=r(t=>{if(!(o.has(t)||l.has(t))){l.add(t);for(const m of[...i.get(t)].sort())c(m);l.delete(t),o.add(t),d.push(t)}},"visit");for(const t of n)c(t);return d}r(_,"topologicalOrder");export{y as q,O as readCatalog,x as rowKey,_ as topologicalOrder};

package/dist/core/import/load/copy.d.ts

@@ -0,0 +1,26 @@
+import type { CanvasDb } from '../../canvas/db.js';
+import { type PathMap } from '../bundle/layout.js';
+import { type Catalog } from './catalog.js';
+import type { IdMap } from './rewrite.js';
+import type { SourceJson } from '../bundle/layout.js';
+export interface CopyResult {
+    inserted: Record<string, number>;
+    mapped: Record<string, number>;
+}
+/** `import_manifest.inserted_keys`: a zstd-compressed JSON array of primary-key tuples (each value as text). */
+export declare const encodeKeys: (keys: string[][]) => Buffer;
+export declare const decodeKeys: (data: Buffer) => string[][];
+export interface CopyInput {
+    db: CanvasDb;
+    runId: string;
+    schema: string;
+    target: string;
+    catalog: Catalog;
+    source: SourceJson;
+    person: string;
+    idMap: IdMap;
+    pathMap: PathMap;
+}
+export declare const copyOrder: (catalog: Catalog) => string[];
+/** Must run inside `withCanvasWrite`. */
+export declare function copyRows(input: CopyInput): Promise<CopyResult>;

package/dist/core/import/load/copy.js

@@ -0,0 +1,6 @@
+var A=Object.defineProperty;var i=(a,t)=>A(a,"name",{value:t,configurable:!0});import{zstdCompressSync as D,zstdDecompressSync as b}from"node:zlib";import{BODIES_TABLE as U,COPIED_TABLES as k,KEY_MAPPED_TABLES as C}from"../bundle/layout.js";import{q as s,rowKey as M,topologicalOrder as F}from"./catalog.js";import{fillEnvironments as H}from"./prepare.js";const h=i((a,t)=>`${s(a)}.${s(t)}`,"sq"),j=i(a=>D(Buffer.from(JSON.stringify(a))),"encodeKeys"),P=i(a=>JSON.parse(b(a).toString("utf8")),"decodeKeys"),v=i(a=>F(a,k),"copyOrder");async function K(a){const{db:t,runId:O,schema:f,target:I,catalog:T,source:l}=a,c=i(e=>h(f,e),"S"),E=i(e=>h(I,e),"T"),m={inserted:{},mapped:{}},N=i(async(e,n)=>{m.inserted[e]=n.length,await t.prepare("INSERT INTO import_manifest (run_id, table_name, inserted_keys) VALUES (?, ?, ?)").run(O,e,j(n))},"manifest");await H(t,f,I,l,a.person);for(const[e,n]of Object.entries(C)){const o=T.tables.get(e).columns.filter(p=>p!==n).map(s).join(", "),d=[],_=await t.prepareUncached(`SELECT ${s(n)}::text AS key FROM ${c(e)} ORDER BY ${s(n)}::bigint`).all();for(const{key:p}of _){const S=await t.prepareUncached(`INSERT INTO ${E(e)} (${o}) SELECT ${o} FROM ${c(e)} WHERE ${s(n)}::text = ? RETURNING ${s(n)}::text AS key`).get(p);await t.prepare("INSERT INTO import_key_map (source_install_id, table_name, source_key, target_key) VALUES (?, ?, ?, ?)").run(l.installId,e,p,S.key),d.push([S.key])}await N(e,d)}await t.prepareUncached(`UPDATE ${c("review_comments")} c SET created_seq = m.target_key::bigint FROM import_key_map m
+    WHERE m.source_install_id = ? AND m.table_name = 'review_comment_events' AND m.source_key = c.created_seq::text`).run(l.installId);for(const e of v(T)){if(e in C)continue;const n=T.tables.get(e),u=Number((await t.prepareUncached(`SELECT count(*) AS n FROM ${c(e)}`).get()).n);if(u===0){m.inserted[e]=0;continue}const o=M(n),d=n.columns.filter(r=>!n.identity.includes(r)),_=n.identity.length>0?n.identity.map(r=>`s.${s(r)}`).join(", "):o.map(r=>`s.${s(r)}`).join(", ");let p=d.map(r=>`s.${s(r)}`),S="";if(e==="messages"){const r=`NOT EXISTS (SELECT 1 FROM ${E("messages")} t WHERE t.message_id = s.message_id)`,g=Number((await t.prepareUncached(`SELECT count(*) AS n FROM ${c("messages")} s WHERE ${r}`).get()).n);if(S=` WHERE ${r}`,g===0){m.inserted[e]=0,await N(e,[]);continue}const w=Number((await t.prepare("UPDATE message_sequence SET seq = seq + ? WHERE id = 1 RETURNING seq").get(g)).seq);p=d.map(y=>y==="seq"?`${w-g} + row_number() OVER (ORDER BY s.seq)`:`s.${s(y)}`)}const L=o.map(r=>`${s(r)}::text`).join(", "),$=n.primaryKey.length===0;$&&(S=` WHERE NOT EXISTS (SELECT 1 FROM ${E(e)} t WHERE ${o.map(r=>`t.${s(r)} IS NOT DISTINCT FROM s.${s(r)}`).join(" AND ")})`);const R=await t.prepareUncached(`INSERT INTO ${E(e)} (${d.map(s).join(", ")}) SELECT ${p.join(", ")} FROM ${c(e)} s${S}
+      ORDER BY ${_}${$?"":` ON CONFLICT (${o.map(s).join(", ")}) DO NOTHING`} RETURNING ${L}`).all();e===U?m.inserted[e]=R.length:await N(e,R.map(r=>Object.values(r))),m.mapped[e]=u-R.length}await t.prepareUncached(`DELETE FROM ${E("charge_totals")} t WHERE (t.month, t.payer) IN (SELECT DISTINCT month, payer FROM ${c("charges")})`).run(),await t.prepareUncached(`INSERT INTO ${E("charge_totals")} (month, payer, funding, sub, grantee, provider, usd, billed_usd)
+    SELECT month, payer, funding, COALESCE(sub, ''), grantee, COALESCE(provider, ''), COALESCE(SUM(usd), 0), COALESCE(SUM(billed_usd), 0)
+    FROM ${E("charges")} WHERE refused IS NULL AND kind <> 'take' AND (month, payer) IN (SELECT DISTINCT month, payer FROM ${c("charges")})
+    GROUP BY month, payer, funding, COALESCE(sub, ''), grantee, COALESCE(provider, '')`).run();for(const[e,n]of[["object",a.idMap.object],["grant",a.idMap.grant],["kind",a.idMap.kind]])for(const[u,o]of n)await t.prepare("INSERT INTO import_id_map (run_id, kind, source_value, target_value) VALUES (?, ?, ?, ?) ON CONFLICT DO NOTHING").run(O,e,u,o);for(const e of a.pathMap)await t.prepare("INSERT INTO import_id_map (run_id, kind, source_value, target_value) VALUES (?, 'path', ?, ?) ON CONFLICT DO NOTHING").run(O,e.from,e.to);return await t.prepare("UPDATE import_runs SET state = 'committed', committed_at = ?, step = 'copy' WHERE run_id = ?").run(new Date().toISOString(),O),m}i(K,"copyRows");export{v as copyOrder,K as copyRows,P as decodeKeys,j as encodeKeys};

package/dist/core/import/load/path-map.d.ts

@@ -0,0 +1,7 @@
+import type { CanvasDb } from '../../canvas/db.js';
+import { type PathMap, type PathPrefix, type SourceJson } from '../bundle/layout.js';
+/** A directory two nodes share (a cwd outside both worktrees) maps once, to the first node's folder: both nodes' rows read the same target and each
+ *  sandbox unpacks its own archive there. */
+export declare function sandboxPathMap(prefixes: readonly PathPrefix[]): PathMap;
+/** One `import_node_files` row per hosted running node the exporter archived. Runs in the copy transaction, after the nodes are copied. */
+export declare function writeNodeFiles(tx: CanvasDb, schema: string, runId: string, source: SourceJson): Promise<number>;

package/dist/core/import/load/path-map.js

@@ -0,0 +1 @@
+var f=Object.defineProperty;var d=(o,t)=>f(o,"name",{value:t,configurable:!0});import{bundleKeys as l}from"../bundle/layout.js";import{q as c}from"./catalog.js";import{ImportLaneError as s}from"./stage.js";const p="/var/lib/crtr",u="/work/imported";function b(o){const t=o.map(e=>{if(!e.from.startsWith("/")||e.from.split("/").includes(".."))throw new s("stage","bundle_invalid",`path prefix ${e.from} of node ${e.node} is not an absolute path`);const n=e.app.replace(/^app:/,"");if(!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(n)||!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(e.node))throw new s("stage","bundle_invalid",`path prefix names app ${e.app} and node ${e.node}`);const r=`${p}/apps/${n}/nodes/${e.node}`,i=e.role==="context"?`${r}/context`:e.role==="worktree"?`${r}/worktree`:`${u}/${e.node}`;return{from:e.from,to:i}});return t.filter((e,n)=>t.findIndex(r=>r.from===e.from)===n)}d(b,"sandboxPathMap");async function _(o,t,e,n){if(n.kind!=="hosted")return 0;const r=[...new Set((n.pathPrefixes??[]).map(a=>a.node))];let i=0;for(const a of r){if(await o.prepareUncached(`SELECT 1 AS found FROM ${c(t)}.nodes WHERE node_id = ? AND status IN ('active', 'idle')`).get(a)===void 0)throw new s("copy","bundle_invalid",`an archive was uploaded for node ${a}, which is not a running node of the bundle`);i+=Number((await o.prepare("INSERT INTO import_node_files (node, blob_key) VALUES (?, ?) ON CONFLICT DO NOTHING").run(a,l.nodeFiles(e,a))).changes)}return i}d(_,"writeNodeFiles");export{b as sandboxPathMap,_ as writeNodeFiles};

package/dist/core/import/load/prepare.d.ts

@@ -0,0 +1,37 @@
+import type { CanvasDb } from '../../canvas/db.js';
+import { type PathMap, type SourceJson } from '../bundle/layout.js';
+import { type Catalog } from './catalog.js';
+/** A revision of a document the target already holds, to be added through repo sync's own arrival path. */
+export interface ArrivingRevision {
+    document: string;
+    rev_id: string;
+    parents: string[];
+    body_hash: string;
+    rationale: string | null;
+    created_at: string;
+}
+/** Rewrite 4: for rows of running nodes of a hosted source, path columns go through the run's map. Ended nodes' rows stay as historical text. */
+export declare function rewritePaths(db: CanvasDb, schema: string, map: PathMap): Promise<number>;
+/** Rewrite 4b: a human request's files live in the blob store under `requests/<id>/` (the exporter uploaded the request dir there). `request_dir` becomes that
+ *  prefix; a `file` or `presentation_dir` inside the old dir keeps its relative path, one outside it was uploaded to `source/<basename>`. A path that is not
+ *  absolute is already a blob path and stays. */
+export declare function rewriteRequestPaths(db: CanvasDb, schema: string): Promise<number>;
+/** A profile whose name the person already uses for another profile is renamed `<name>-<install id>` (staging only; runs before the pre-check). */
+export declare function renameClashingProfiles(db: CanvasDb, schema: string, target: string, installId: string, person: string): Promise<number>;
+/** Fill: a staged profile with no environment gets the source's machine environment (a Mac) or the person's Blaxel environment (hosted, created if
+ *  absent). Runs in the copy transaction: it writes target objects. */
+export declare function fillEnvironments(tx: CanvasDb, schema: string, target: string, source: SourceJson, person: string): Promise<number>;
+/** Staged edits that need nothing from the target but its key map: limits the directory or an operator wrote stay out, a hosted source's own
+ *  machine environment is marked for the drop step, claims of the old runtime's lanes are cleared, and rows of the identity-keyed tables already in
+ *  `import_key_map` are not staged again. Returns the rows removed per table. */
+export declare function pruneStaged(db: CanvasDb, schema: string, catalog: Catalog, source: SourceJson): Promise<Record<string, number>>;
+/** A staged document whose id the target already holds (repo sync keeps the id across runtimes) is not inserted: its revisions arrive through
+ *  `insertImportedRevisions`. Removes its staged object, document, revision and parent rows and returns the revisions. Runs before the pre-check. */
+export declare function takeRepoSyncedDocuments(db: CanvasDb, schema: string, target: string): Promise<ArrivingRevision[]>;
+export interface Collision {
+    table: string;
+    key: string;
+    values: string[];
+}
+/** Pre-check (I9): every non-primary unique key and every text primary key the target already holds. Throws `unique_conflict` naming the first 10 values. */
+export declare function precheck(db: CanvasDb, schema: string, target: string, catalog: Catalog, tables: readonly string[], skip: ReadonlySet<string>, seqLike: ReadonlyMap<string, string[]>): Promise<void>;

package/dist/core/import/load/prepare.js

@@ -0,0 +1,10 @@
+var y=Object.defineProperty;var d=(n,o)=>y(n,"name",{value:o,configurable:!0});import{createProfileBlaxelEnvironment as v}from"../../environments.js";import{KEY_MAPPED_TABLES as U,mapPath as S}from"../bundle/layout.js";import{ImportLaneError as O}from"./stage.js";import{q as l}from"./catalog.js";const $=d((n,o)=>`${l(n)}.${l(o)}`,"sq");async function F(n,o,c){if(c.length===0)return 0;const e=d(s=>$(o,s),"S"),t=`(SELECT node_id FROM ${e("nodes")} WHERE status IN ('active', 'idle'))`;let a=0;const E=d(async(s,r,i,u=!1)=>{const _=await n.prepareUncached(`SELECT ${l(r)}::text AS value FROM ${e(s)} WHERE ${i} AND ${l(r)} IS NOT NULL`).all();for(const{value:R}of _){const T=u?H(R,c):S(c,R);T!==R&&(await n.prepareUncached(`UPDATE ${e(s)} SET ${l(r)} = ? WHERE ${l(r)}::text = ? AND ${i}`).run(T,R),a+=1)}},"apply");return await E("nodes","cwd",`node_id IN ${t}`),await E("worktrees","path",`node_id IN ${t}`),await E("worktrees","repo_root",`node_id IN ${t}`),await E("crons","cwd",`anchor_node IN ${t}`),await E("provider_approvals","prepared_files","TRUE",!0),await E("upload_uses","path",`run_id IN ${t}`),a}d(F,"rewritePaths");async function g(n,o){const c=$(o,"human_requests"),e=d(a=>`CASE WHEN ${a} IS NULL OR ${a} NOT LIKE '/%' THEN ${a}
+    WHEN rtrim(${a}, '/') = rtrim(request_dir, '/') THEN 'requests/' || request_id
+    WHEN ${a} LIKE rtrim(request_dir, '/') || '/%' THEN 'requests/' || request_id || '/' || substr(${a}, length(rtrim(request_dir, '/')) + 2)
+    ELSE 'requests/' || request_id || '/source/' || regexp_replace(${a}, '^.*/', '') END`,"moved"),t=await n.prepareUncached(`UPDATE ${c} SET file = ${e("file")}, presentation_dir = ${e("presentation_dir")},
+    request_dir = CASE WHEN request_dir LIKE '/%' THEN 'requests/' || request_id ELSE request_dir END`).run();return Number(t.changes)}d(g,"rewriteRequestPaths");function H(n,o){const c=d(e=>typeof e=="string"?S(o,e):Array.isArray(e)?e.map(c):e!==null&&typeof e=="object"?Object.fromEntries(Object.entries(e).map(([t,a])=>[t,c(a)])):e,"walk");try{return JSON.stringify(c(JSON.parse(n)))}catch{return S(o,n)}}d(H,"rewriteJsonPaths");async function j(n,o,c,e,t){const a=d(r=>$(o,r),"S"),E=await n.prepareUncached(`SELECT id, name FROM ${a("profiles")} ORDER BY id`).all();let s=0;for(const r of E)await n.prepareUncached(`SELECT 1 AS found FROM ${$(c,"profiles")} WHERE person = ? AND name = ? AND id <> ?`).get(t,r.name,r.id)!==void 0&&(await n.prepareUncached(`UPDATE ${a("profiles")} SET name = ? WHERE id = ?`).run(`${r.name}-${e}`,r.id),s+=1);return s}d(j,"renameClashingProfiles");async function q(n,o,c,e,t){const a=d(r=>$(o,r),"S");let E=0;const s=await n.prepareUncached(`SELECT id, grantee FROM ${a("profiles")} WHERE environment_id IS NULL ORDER BY id`).all();for(const r of s){let i=e.kind==="machine"?e.environmentObject??null:null;if(e.kind==="hosted"&&(i=(await n.prepareUncached(`SELECT environment_id FROM ${$(c,"profiles")} WHERE id = ?`).get(r.id))?.environment_id??await v(n,{profileId:r.id,grantee:r.grantee??"app:terminal",person:t})),i===null)throw new O("fill","bundle_invalid",`profile ${r.id} has no environment and the source names none`);await n.prepareUncached(`UPDATE ${a("profiles")} SET environment_id = ? WHERE id = ?`).run(i,r.id),E+=1}return E}d(q,"fillEnvironments");async function x(n,o,c,e){const t=d(s=>$(o,s),"S"),a={},E=d(async(s,r,...i)=>{const u=Number((await n.prepareUncached(r).run(...i)).changes);u>0&&(a[s]=(a[s]??0)+u)},"del");await E("limits",`DELETE FROM ${t("limits")} WHERE source <> 'person'`),e.kind==="hosted"&&(await n.prepareUncached(`UPDATE ${t("profiles")} SET environment_id = NULL WHERE environment_id IN (SELECT object FROM ${t("environments")})`).run(),await n.prepareUncached(`UPDATE ${t("objects")} SET home_machine = 'import-hosted-source' WHERE id IN (SELECT object FROM ${t("environments")})`).run());for(const[s,r]of Object.entries(U))await E(s,`DELETE FROM ${t(s)} WHERE ${l(r)}::text IN (SELECT source_key FROM import_key_map WHERE source_install_id = ? AND table_name = ?)`,e.installId,s);for(const s of c.tables.values())s.columns.includes("claimed_by")&&s.columns.includes("lease_expires_at")&&await n.prepareUncached(`UPDATE ${t(s.name)} SET claimed_by = NULL, lease_expires_at = NULL WHERE claimed_by IS NOT NULL OR lease_expires_at IS NOT NULL`).run();return a}d(x,"pruneStaged");async function b(n,o,c){const e=d(E=>$(o,E),"S"),t=`(SELECT d.object FROM ${e("documents")} d WHERE EXISTS (SELECT 1 FROM ${$(c,"documents")} t WHERE t.object = d.object))`;await n.exec(`CREATE TABLE ${e("_arr_revisions")} AS SELECT r.* FROM ${e("revisions")} r WHERE r.document IN ${t};
+    CREATE TABLE ${e("_arr_parents")} AS SELECT p.* FROM ${e("revision_parents")} p WHERE p.child IN (SELECT rev_id FROM ${e("revisions")} WHERE document IN ${t})`);const a=await n.prepareUncached(`SELECT r.document, r.rev_id, r.body_hash, r.rationale, r.created_at,
+      COALESCE((SELECT array_agg(p.parent) FROM ${e("revision_parents")} p WHERE p.child = r.rev_id), ARRAY[]::text[]) AS parents
+    FROM ${e("revisions")} r WHERE r.document IN ${t} ORDER BY r.document, r.number`).all();return await n.prepareUncached(`DELETE FROM ${e("revision_parents")} WHERE child IN (SELECT rev_id FROM ${e("revisions")} WHERE document IN ${t})`).run(),await n.prepareUncached(`DELETE FROM ${e("revisions")} WHERE document IN ${t}`).run(),await n.prepareUncached(`DELETE FROM ${e("objects")} WHERE id IN ${t}`).run(),await n.prepareUncached(`DELETE FROM ${e("documents")} WHERE object IN ${t}`).run(),a.map(E=>({...E}))}d(b,"takeRepoSyncedDocuments");async function k(n,o,c,e,t,a,E){const s=d(i=>[...E.get(i)??[],...i==="profiles"?["environment_id"]:[],"claimed_by","lease_expires_at"],"ignored"),r=[];for(const i of t){const u=e.tables.get(i);if(u===void 0||a.has(i)||u.primaryKey.length===0)continue;const _=u.primaryKey,R=_.some(p=>u.identity.includes(p)),T=_.map(p=>`s.${l(p)} = t.${l(p)}`).join(" AND "),w=R?"TRUE":_.map(p=>`s.${l(p)} IS DISTINCT FROM t.${l(p)}`).join(" OR "),I=new Set([...u.identity,...E.get(i)??[]]);for(const p of e.uniqueKeys.filter(f=>f.table===i&&!f.columns.every(m=>I.has(m)))){const f=p.predicate===null?"":` WHERE ${p.predicate}`,m=p.columns.map(h=>`s.${l(h)} = t.${l(h)}`).join(" AND "),L=await n.prepareUncached(`SELECT ${p.columns.map(h=>`s.${l(h)}::text`).join(" || ',' || ")} AS value
+        FROM (SELECT * FROM ${$(o,i)}${f}) s JOIN (SELECT * FROM ${$(c,i)}${f}) t ON ${m} AND (${w}) LIMIT 10`).all();L.length>0&&r.push({table:i,key:p.name,values:L.map(h=>h.value)})}const N=u.columns.filter(p=>!u.identity.includes(p)&&!s(i).includes(p));if(N.length>0&&!R){const p=N.map(m=>`s.${l(m)} IS DISTINCT FROM t.${l(m)}`).join(" OR "),f=await n.prepareUncached(`SELECT ${_.map(m=>`s.${l(m)}::text`).join(" || ',' || ")} AS value
+        FROM ${$(o,i)} s JOIN ${$(c,i)} t ON ${T} WHERE ${p} LIMIT 10`).all();f.length>0&&r.push({table:i,key:"primary key payload",values:f.map(m=>m.value)})}}if(r.length>0){const i=r[0];throw new O("pre-check","unique_conflict",`${i.table} ${i.key} collides with the target: ${i.values.join(", ")}`,{collisions:r})}}d(k,"precheck");export{q as fillEnvironments,k as precheck,x as pruneStaged,j as renameClashingProfiles,F as rewritePaths,g as rewriteRequestPaths,b as takeRepoSyncedDocuments};

package/dist/core/import/load/rewrite.d.ts

@@ -0,0 +1,39 @@
+import { type CanvasDb } from '../../canvas/db.js';
+import { ImportLaneError } from './stage.js';
+import { type Catalog } from './catalog.js';
+export interface RewriteInput {
+    db: CanvasDb;
+    /** The staging schema. */
+    schema: string;
+    /** The crouter schema the rows are copied into. */
+    target: string;
+    catalog: Catalog;
+    sourcePerson: string;
+    targetPerson: string;
+    /** The control plane's fleet runtime principal (`CRTR_RUNTIME`), the key of the directory's grants. */
+    fleetRuntime: string | null;
+    /** `source.shippedBodies`: shipped document id → hash of its body, which is a `bodies` row of the bundle (copied with the table). */
+    shippedBodies: Readonly<Record<string, string>>;
+}
+/** Source id → target id, per kind. Persisted into `import_id_map` in the copy transaction. */
+export interface IdMap {
+    object: Map<string, string>;
+    grant: Map<string, string>;
+    kind: Map<string, string>;
+}
+/** Object-id columns that carry no foreign key (design-import, "Id columns"). */
+export declare const OBJECT_ID_COLUMNS: ReadonlyArray<[string, string]>;
+/** Every column that holds an object id, per table: the foreign keys onto `objects` in the target's catalog, then the ones without a foreign key. */
+export declare function objectIdColumns(catalog: Catalog): Map<string, Set<string>>;
+/** Rewrite 1: `substitutePerson` against the staging schema (every table it touches is staged, the ones the bundle does not dump empty). */
+export declare function rewritePerson(input: RewriteInput): Promise<void>;
+/** The target's grant for (fleet runtime, sub, grantee), the key the directory writes an importing person's grants under. The lane's wait for those
+ *  grants (`run.ts`) and rewrite 2 both look a grant up here. A null fleet runtime (`CRTR_RUNTIME` unset) holds none. */
+export declare function findFleetGrant(db: CanvasDb, target: string, fleetRuntime: string | null, sub: string, grantee: string): Promise<string | undefined>;
+/** The `grant_missing` failure, for the grantees the target holds no grant for. */
+export declare function grantMissing(grantees: readonly string[]): ImportLaneError;
+/** Rewrite 2 (id map): build the map, drop the staged rows of mapped objects, rewrite every id column through it. */
+export declare function rewriteIds(input: RewriteInput): Promise<IdMap>;
+/** The drop step: federation stubs' objects and every staged row that points at a dropped row, then the assertion that no staged foreign
+ *  key points at a row that is neither staged nor in the target. Returns rows dropped per table. */
+export declare function dropStubRows(input: RewriteInput): Promise<Record<string, number>>;