@anchrd/intel-contract 0.13.0 → 0.14.0

package/dist/contract/bundle.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+export declare const BundleManifestFilename = "manifest.json";
+/**
+ * What a bundle entry can be. `flow` joins the node kinds because a flow shares the folder tree
+ * without being a node (ADR-0004), and the bundle mirrors the tree, not the tables.
+ *
+ * ⚠️ `agent` and `board` are STILL HERE, and that is the one place in this file where a value
+ * survives its feature (#390). A bundle is somebody else's file: an export written before Agents
+ * and Board were parked (#385) is a correct export, and it has to PARSE so the import can refuse it
+ * by name — with the entry, the kind and the branch the code is on. Take them out and the same
+ * bundle fails as `unexpected enum value`, which sends its holder looking for a broken file that is
+ * not broken.
+ *
+ * They belong to the wire format of a file that already exists, not to the product. Nothing may
+ * create either kind; `NodeKind` is the enum that says so.
+ */
+export declare const BundleEntryKind: z.ZodEnum<{
+    folder: "folder";
+    document: "document";
+    table: "table";
+    attachment: "attachment";
+    agent: "agent";
+    board: "board";
+    flow: "flow";
+}>;
+export type BundleEntryKind = z.infer<typeof BundleEntryKind>;
+export declare const BundleManifestEntry: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        folder: "folder";
+        document: "document";
+        table: "table";
+        attachment: "attachment";
+        agent: "agent";
+        board: "board";
+        flow: "flow";
+    }>;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    mediaType: z.ZodNullable<z.ZodString>;
+    path: z.ZodString;
+}, z.core.$strict>;
+export type BundleManifestEntry = z.infer<typeof BundleManifestEntry>;
+export declare const BundleExclusion: z.ZodEnum<{
+    "version-history": "version-history";
+    grants: "grants";
+    "flow-runs": "flow-runs";
+    "archived-nodes": "archived-nodes";
+}>;
+export type BundleExclusion = z.infer<typeof BundleExclusion>;
+export declare const BundleManifest: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    exportedAt: z.ZodISODateTime;
+    rootId: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            table: "table";
+            attachment: "attachment";
+            agent: "agent";
+            board: "board";
+            flow: "flow";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        mediaType: z.ZodNullable<z.ZodString>;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    excluded: z.ZodArray<z.ZodEnum<{
+        "version-history": "version-history";
+        grants: "grants";
+        "flow-runs": "flow-runs";
+        "archived-nodes": "archived-nodes";
+    }>>;
+}, z.core.$strict>;
+export type BundleManifest = z.infer<typeof BundleManifest>;
+export declare const BundleImportResult: z.ZodObject<{
+    nodes: z.ZodNumber;
+    flows: z.ZodNumber;
+    rootNodeIds: z.ZodArray<z.ZodString>;
+    replayed: z.ZodBoolean;
+}, z.core.$strict>;
+export type BundleImportResult = z.infer<typeof BundleImportResult>;

package/dist/contract/bundle.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { IntelId, IsoDateTime } from "./contract.js";
+// ── Bundle export (#136) ────────────────────────────────────────────────────────────────────────
+// The one name the importer looks for at the zip root. A different spelling would make a bundle a
+// naked folder, so the constant lives in the contract rather than in each surface.
+export const BundleManifestFilename = "manifest.json";
+/**
+ * What a bundle entry can be. `flow` joins the node kinds because a flow shares the folder tree
+ * without being a node (ADR-0004), and the bundle mirrors the tree, not the tables.
+ *
+ * ⚠️ `agent` and `board` are STILL HERE, and that is the one place in this file where a value
+ * survives its feature (#390). A bundle is somebody else's file: an export written before Agents
+ * and Board were parked (#385) is a correct export, and it has to PARSE so the import can refuse it
+ * by name — with the entry, the kind and the branch the code is on. Take them out and the same
+ * bundle fails as `unexpected enum value`, which sends its holder looking for a broken file that is
+ * not broken.
+ *
+ * They belong to the wire format of a file that already exists, not to the product. Nothing may
+ * create either kind; `NodeKind` is the enum that says so.
+ */
+export const BundleEntryKind = z.enum([
+    "folder",
+    "document",
+    "table",
+    "attachment",
+    "agent",
+    "board",
+    "flow",
+]);
+// One entry of the manifest: the identity a re-import needs, next to the relative path where the
+// bytes sit in the zip. A folder carries no media type — it has no bytes.
+export const BundleManifestEntry = z.strictObject({
+    id: IntelId,
+    kind: BundleEntryKind,
+    title: z.string().min(1).max(240),
+    description: z.string().max(2_000).nullable(),
+    mediaType: z.string().min(1).max(160).nullable(),
+    // Relative to the zip root, forward slashes, no leading slash. Folders end with a slash so an
+    // empty folder still has an address.
+    path: z.string().min(1).max(4_000),
+});
+// What an export leaves out on purpose, named so a bundle says it rather than a reader guessing:
+// version history, grants/shares, flow runs, and archived nodes are not in any bundle (#136).
+export const BundleExclusion = z.enum(["version-history", "grants", "flow-runs", "archived-nodes"]);
+export const BundleManifest = z.strictObject({
+    version: z.literal(1),
+    exportedAt: IsoDateTime,
+    // The node the export started at; `null` is the root of the tree — the whole installation as the
+    // exporting caller may read it.
+    rootId: IntelId.nullable(),
+    entries: z.array(BundleManifestEntry),
+    excluded: z.array(BundleExclusion),
+});
+// ── Bundle import (#137) ────────────────────────────────────────────────────────────────────────
+// What one import made. Import always creates new nodes — no merge, no overwrite, no restored IDs
+// (#137, phase 1) — so the answer is counts and the new roots, never a diff. `replayed` marks the
+// idempotent second answer to the same key: nothing was created twice.
+export const BundleImportResult = z.strictObject({
+    nodes: z.number().int().nonnegative(),
+    flows: z.number().int().nonnegative(),
+    rootNodeIds: z.array(IntelId),
+    replayed: z.boolean(),
+});