@wenathlan/devthink 2.0.13 → 2.0.15

package/dist/export.d.ts

@@ -0,0 +1,311 @@
+/** The export module of the 1.1.90 consolidation: every correlated variation of the data egress, the minimization and the portability logic interned in this one file, so the module family carries one surface without duplicate variations. */
+import type { cookiejarrecord, datainventory, dropimportsession, exportallbundle, exportdescriptor, exportresult, immutablelogentry, importexportpayload, localrule, purgepolicy, quarantineentry, scanverdict, sitenote, storedrunlog, syncsettings, syncrecord, telemetrypolicy } from "./types.js";
+/**
+ * Exporttools logic of the 1.1.67 family.
+ * Runs, extractions and notes move to disk here: every export carries its descriptor with the format and the scope, the log chain verifies before any byte leaves the store, the maskinputs verdicts apply in every format, and an unmasked value refuses the export in full.
+ * The tools never widen an export: a refused export writes nothing, and no format ships a value the mask verdicts held back.
+ */
+/** The export formats the tools render: csv for tables, json for structured consumers, log for the chain lines, jsonl for the json lines streams and markdown for the table documents. */
+export declare const exportformats: readonly string[];
+/** The export scopes the tools serve: the runs of a chain, the extractions of a run, the notes of a profile, beside the session, audit and extraction scopes the 1.1.80 exportdata command exports. */
+export declare const exportscopes: readonly string[];
+/** Builds and validates one export descriptor: the format and the scope stay the reviewed pair the command declared. */
+export declare function exportdescriptorof(format: string, scope: string): exportdescriptor;
+/** Escapes one csv field: the field quotes when it carries a comma, a quote or a newline, and a quote doubles inside. */
+export declare function csvfield(value: string): string;
+/** Renders rows as csv: the header carries the sorted field names and every row escapes its fields the csv way. */
+export declare function csvof(rows: Array<Record<string, string>>): string;
+/** Escapes one markdown table cell: the backslash escapes first so a value that already carries one never collides with the pipe escape, the pipe follows and a newline breaks the cell into a line break the table carries literally. */
+export declare function markdownfield(value: string): string;
+/** Renders rows as one markdown table: the header carries the sorted field names, the separator row fixes the column count and every row escapes its cells the markdown way. */
+export declare function markdownof(rows: Array<Record<string, string>>): string;
+/** Renders records as json lines: one compact json document per line, so a stream consumer reads one record at a time with no delimiter bookkeeping. */
+export declare function jsonlinesof(records: Array<Record<string, unknown>>): string;
+/** The secret field shapes an export refuses in full when their values carry no mask marker: the same shapes the importexport bundle refuses, so no format launders an unmasked store value. */
+export declare const secretfieldshapes: readonly string[];
+/** Reads the secret named fields whose raw values carry no mask marker: every one of them refuses the export under any format, because masking at export time would launder an unmasked store value. */
+export declare function unmaskedfieldsof(records: Array<Record<string, unknown>>): string[];
+/** Exports records in the descriptor format with the mask verdicts honored: the verdicts mask the fields they hold back in every format, a raw secret value refuses the export in full because masking at export time would launder an unmasked store, and a refused export writes nothing. */
+export declare function exportrecords(input: {
+    descriptor: exportdescriptor;
+    records: Array<Record<string, unknown>>;
+    shapes: string[];
+    path?: string;
+}): {
+    result: exportresult;
+    content: string;
+};
+/** Reads the row view of one immutable log chain: one row per entry with its identity, kind, origin, step, summary and time. */
+export declare function chainrows(entries: immutablelogentry[]): Array<Record<string, string>>;
+/** Exports one sealed run log in the descriptor format: the chain verifies before any byte leaves the store, so a broken chain refuses the export in full. */
+export declare function exportchain(input: {
+    descriptor: exportdescriptor;
+    log: storedrunlog;
+    shapes: string[];
+    path?: string;
+}): Promise<{
+    result: exportresult;
+    content: string;
+}>;
+/** Reads the export row view of one site note: the identity and provenance beside the plain body or the sealed body exactly as the note stores it, so a sensitive note never ships its plaintext. */
+export declare function noterow(note: sitenote): Record<string, string>;
+/** Exports notes in the descriptor format with the mask verdicts honored: the plain bodies and the sealed bodies ride the same masking gate as every other record. */
+export declare function exportnotes(input: {
+    descriptor: exportdescriptor;
+    notes: sitenote[];
+    shapes: string[];
+    path?: string;
+}): {
+    result: exportresult;
+    content: string;
+};
+/** Exports extraction rows in the descriptor format: the extracted values mask under the same verdicts, and an unmasked sensitive value refuses the export. */
+export declare function exportextractions(input: {
+    descriptor: exportdescriptor;
+    rows: Array<Record<string, unknown>>;
+    shapes: string[];
+    path?: string;
+}): {
+    result: exportresult;
+    content: string;
+};
+/**
+ * Data minimization logic of the 1.1.79 family.
+ * Every correlated rule for the smallest possible data footprint lives in this one module: the localfirst pass that keeps extraction, aggregation and diffing on the device and strips the identity fields the reviewed plan never listed while the localrule fields never leave the device at all; the notelemetry posture that keeps every counter inside the local memory with the worker free of outbound usage calls; the optinsync consent that stays disabled until the user turns each data class on and stamps the consent per class; the encryptsync pass that derives the key from the user passphrase, encrypts every payload before the transport and stamps the format version while refusing a sync without the passphrase; the purgeonrequest pass that deletes stored data by scope on the user request, demands the typed confirmation for the full scope, preserves the immutable audit hashes and reports every deleted key; the exportall bundle that carries every stored record — runs, memory, captures, settings and provenance — into one portable file the streaming pass walks without a size cap; the cookiejar isolation that assigns one jar per task run, scopes every cookie read and write to the active jar and seals the jar at the run completion under the user expiry window; the cleanupafterrun pass that clears the task artifacts of a completed run while the artifacts the user flagged for retention stay; and the enforcequarantine rule that holds every download in the sandbox folder until the scanner verdict arrives and releases or deletes the file by the verdict alone.
+ * The module extends the reviewed families instead of duplicating them: the cookie entries ride the cookierecord shapes the cookie control family already writes, the quarantine verdicts reuse the scanverdict grammar and the quarantineentry record of the security family with its new lifecycle status, the exportall provenance composes the provlog entries of the pipeline family, and the purge receipts answer the audit trail the immutable log family already seals.
+ * Every impure move stays behind an injected seam — the key derivation, the payload encryption, the sync transport and the scanner hook resolve through functions the executor wires — while every cadence, retention, scope, timing and expiry stays the user's with no code default: an absent sync cadence keeps every pass off, an absent cleanup timing leaves every pass to the explicit user action, an absent jar expiry keeps every sealed jar until the user purges it, and no minimization path ever bypasses a review.
+ */
+/** Key derivation seam: one user passphrase resolves to the derived key material; the extension executor wires the webcrypto derivation, tests wire plain fixtures. The passphrase itself never persists and never rides a payload. */
+export type keyderive = (passphrase: string) => Promise<string>;
+/** Payload encryption seam: one derived key with one plaintext payload resolves to the cipher text; the extension executor wires the webcrypto cipher, tests wire plain fixtures. */
+export type payloadencrypt = (key: string, payload: string) => Promise<string>;
+/** Sync transport seam: one encrypted payload with the classes it carries resolves to the delivery state; the extension executor wires the user configured sync backend, tests wire plain fixtures and counters. */
+export type syncsend = (payload: string, classes: string[]) => Promise<{
+    delivered: boolean;
+    endpoint?: string;
+}>;
+/** Scanner hook seam: one quarantined file resolves to the verdict of the user configured scanner; the extension executor wires the configured scan hook endpoint, tests wire plain fixtures. */
+export type scannerhook = (entry: {
+    path: string;
+    reason: string;
+    digest?: string;
+}) => Promise<scanverdict>;
+/** The minimization kinds of the 1.1.79 family, listed among the available capabilities of every proposal request. */
+export declare const minimizationkinds: string[];
+/**
+ * Processes one extraction through the local first pass: extraction, aggregation and diffing stay on the device, the identity fields strip unless the reviewed plan listed them, and the localrule fields of the origin strip always — they never leave the device for any review — while the report names every stripped and every local held field so the audit trail answers what the extraction stopped carrying.
+ */
+export declare function localfirst(input: {
+    origin: string;
+    rows: Array<Record<string, string>>;
+    reviewedfields?: string[];
+    rules: localrule[];
+    now: number;
+}): {
+    rows: Array<Record<string, string>>;
+    stripped: string[];
+    localheld: string[];
+    reason: string;
+};
+/**
+ * Lists the local rule fields an outbound payload carries: the localgate and the protocol boundary refuse any payload that answers with one entry or more, because a field marked local never leaves the device for any transport.
+ */
+export declare function localfieldsof(payload: Record<string, unknown>, rules: localrule[]): string[];
+/**
+ * Reads the telemetry policy fixed to off: the enabled literal stays false by construction — the type makes an on state unrepresentable — and every counter keeps living inside the local memory, so the popup names the posture and the tests hold the invariant.
+ */
+export declare function fixedtelemetrypolicy(now: number): telemetrypolicy;
+/**
+ * Turns the sync opt in on per data class: sync stays disabled until the user lists every data class and enables each one, every enablement stamps the consent per class for the audit trail, and a class the listing never offered never enables — an unlisted class answers no consent.
+ */
+export declare function optinsync(input: {
+    current?: syncsettings;
+    offered: string[];
+    enable: string[];
+    now: number;
+}): {
+    settings: syncsettings;
+    consent: Array<{
+        dataclass: string;
+        at: number;
+    }>;
+};
+/**
+ * Encrypts one sync payload before the transport: the key derives from the user passphrase through the derivation seam, the payload encrypts through the cipher seam, the format version tags the envelope, and a sync without the passphrase refuses — a passphrase the user never typed never defaults in code.
+ */
+export declare function encryptsync(input: {
+    payload: string;
+    passphrase?: string;
+    derive: keyderive;
+    encrypt: payloadencrypt;
+}): Promise<{
+    cipher: string;
+    formattag: string;
+    reason: string;
+}>;
+/**
+ * Runs one sync pass through the seams: only the classes the user opted in ride the payload, the encryptsync pass encrypts before the transport seam fires, and the syncrecord carries the payload hash with the format tag — a plaintext or an unconsented class never reaches the transport.
+ */
+export declare function syncpass(input: {
+    payload: string;
+    classes: string[];
+    settings: syncsettings;
+    passphrase?: string;
+    derive: keyderive;
+    encrypt: payloadencrypt;
+    send: syncsend;
+    now: number;
+}): Promise<{
+    record: syncrecord;
+    delivered: boolean;
+    reason: string;
+}>;
+/**
+ * Deletes stored data by scope on the user request: the purge answers the inventory the device holds, the full scope demands the typed confirmation phrase, the audit class never deletes because the immutable audit hashes survive every purge, and the report lists every deleted key for the audit trail.
+ */
+export declare function purgeonrequest(input: {
+    policy: purgepolicy;
+    typed: string;
+    inventory: datainventory[];
+    now: number;
+}): {
+    deleted: string[];
+    kept: string[];
+    audithashespreserved: boolean;
+    reason: string;
+};
+/**
+ * Bundles every stored record into one portable file: the runs, the memory items, the captures, the settings and the provenance entries ride one exportall bundle the user explicitly asked for, the record count and the byte size name what left, and nothing here caps the size because a bundle the user asked for streams whole.
+ */
+export declare function exportall(input: {
+    runs: string[];
+    memory: string[];
+    captures: string[];
+    settings: boolean;
+    provenance: string[];
+    now: number;
+}): exportallbundle;
+/**
+ * Streams one exportall bundle in chunks without a size cap: the chunk size stays the explicit choice of the caller because no code ceiling ever refuses a large bundle; the chunks concatenate back into the bundle payload byte for byte.
+ */
+export declare function streambundle(input: {
+    bundle: exportallbundle;
+    chunksize: number;
+}): string[];
+/**
+ * Assigns one cookie jar to a task run: the jar carries its id, the run it isolates and the cookie entries scoped inside it, so one task run never shares its cookie state with another; an empty jar at the run start holds nothing until a reviewed cookie step writes.
+ */
+export declare function newjar(input: {
+    runid: string;
+    now: number;
+    id?: string;
+}): cookiejarrecord;
+/**
+ * Scopes one cookie read or write to the active jar: a write appends or replaces the entries inside the jar it belongs to — and a sealed jar refuses every write because a completed run never changes its cookie state — while a read answers exactly the entries the jar holds for the domain the step named.
+ */
+export declare function jarscope(input: {
+    jar: cookiejarrecord;
+    operation: "read" | "write";
+    cookies?: Array<{
+        name: string;
+        domain: string;
+        value: string;
+        path?: string;
+        expiresat?: number;
+    }>;
+    domain?: string;
+    now: number;
+}): {
+    jar: cookiejarrecord;
+    entries: Array<{
+        name: string;
+        domain: string;
+        value: string;
+        path?: string;
+        expiresat?: number;
+    }>;
+    reason: string;
+};
+/**
+ * Seals the jar of a completed run: the seal stamps the completion time, the user configured expiry window marks when the sealed jar's entries expire for the automatic cleanup, and an absent window keeps the jar until the user purges it because the expiry never defaults in code.
+ */
+export declare function sealjar(input: {
+    jar: cookiejarrecord;
+    now: number;
+    expiry?: number;
+}): cookiejarrecord;
+/**
+ * Clears the task artifacts of a completed run: the classes the cleanup schedule names leave while the artifacts the user flagged for retention stay, and an absent class list clears nothing because the cleanup stays the user's schedule with no code default.
+ */
+export declare function cleanupafterrun(input: {
+    runid: string;
+    artifacts: Array<{
+        id: string;
+        dataclass: string;
+        retained?: boolean;
+    }>;
+    classes: string[];
+    now: number;
+}): {
+    cleared: string[];
+    kept: string[];
+    reason: string;
+};
+/**
+ * Holds a download in the sandbox folder until the scanner verdict arrives and releases or deletes the file by the verdict alone: a clean verdict releases, a flagged verdict deletes, and a pending or error verdict holds — a file without a verdict never opens, and a hook failure never releases anything.
+ */
+export declare function enforcequarantine(input: {
+    path: string;
+    reason: string;
+    scan?: scanverdict;
+    digest?: string;
+    now: number;
+    id?: string;
+}): {
+    entry: quarantineentry;
+    action: "hold" | "release" | "delete";
+    reason: string;
+};
+/**
+ * Builds one data inventory entry of a stored family: the serialized size and the record count answer what the device holds, so the purge and the exportall bundle scope exactly over the inventory and never guess.
+ */
+export declare function inventoryentry(input: {
+    key: string;
+    dataclass: string;
+    value: unknown;
+    now: number;
+}): datainventory;
+/**
+ * Importexport and dropimport logic of the 1.1.65 family.
+ * Settings and data move between profiles here: the importexport payload carries the originprofiles, the siteprofiles, the site notes and the preferences of one profile while the secretvault values and the unmasked logs never enter any bundle under any flag; and the dropimport accepts the csv, json and workflow files the user drops on the optionspage and the dashboardpage with its file kind detection naming what it found.
+ * No bundle is ever forced: every import lands under the same review, and no export path ever ships a secret or an unmasked log value.
+ */
+/** Builds one importexport payload: the settings and data bundle of one profile with the originprofiles, the siteprofiles, the notes and the preferences and the honest exclusion list of everything that stayed out. */
+export declare function importexportpayloadof(input: {
+    profile: string;
+    originprofiles: Array<Record<string, unknown>>;
+    siteprofiles: Array<Record<string, unknown>>;
+    notes: Array<Record<string, unknown>>;
+    preferences: Record<string, unknown>;
+    at: number;
+}): importexportpayload;
+/** Validates one importexport payload for import: a bundle that carries secretvault values or unmasked logs refuses under any flag, and the payload needs its profile and contents. */
+export declare function importexportvalidate(payload: importexportpayload): {
+    ok: boolean;
+    reason: string;
+};
+/** Applies one importexport payload to the current preferences: the imported keys replace their current values while the secrets exclusion list stays untouched because no secret ever rides a bundle. */
+export declare function applyimport(payload: importexportpayload, current: Record<string, unknown>): {
+    preferences: Record<string, unknown>;
+    applied: string[];
+};
+/** Detects the file kind of one dropped file: the extension names csv, json and workflow files while the head of the content confirms the json and workflow shapes. */
+export declare function detectfilekind(filename: string, head: string): dropimportsession["kind"] | undefined;
+/** Builds one dropimport session of a file dropped on the optionspage or the dashboardpage: the detected kind names what the import path takes while an unknown kind refuses the session. */
+export declare function dropimportof(input: {
+    filename: string;
+    bytes: number;
+    head: string;
+    at: number;
+}): dropimportsession;
+//# sourceMappingURL=export.d.ts.map