@anchrd/intel-contract 0.15.0 → 0.16.0

package/dist/contract/flow.d.ts

@@ -709,6 +709,15 @@ export declare const ArchiveFlowInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type ArchiveFlowInput = z.infer<typeof ArchiveFlowInput>;
+export declare const PurgeFlowInput: z.ZodObject<{
+    flowId: z.ZodString;
+}, z.core.$strict>;
+export type PurgeFlowInput = z.infer<typeof PurgeFlowInput>;
+export declare const PurgeFlowResult: z.ZodObject<{
+    purged: z.ZodLiteral<true>;
+    title: z.ZodString;
+}, z.core.$strict>;
+export type PurgeFlowResult = z.infer<typeof PurgeFlowResult>;
 export declare const ListFlowsInput: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     includeArchived: z.ZodOptional<z.ZodBoolean>;

package/dist/contract/flow.js

@@ -292,6 +292,16 @@ export const ArchiveFlowInput = z.strictObject({
         .describe("`true` archives the flow, `false` restores it. Nothing is deleted and every version stays readable."),
     idempotencyKey: IdempotencyKey,
 });
+// ⚠️ The flow half of the one irreversible act in Intel (#457). No `baseUpdatedAt`, no
+// `idempotencyKey`, for the same two reasons the node's has neither: an archived flow is not being
+// edited, and a replay has nothing to replay — deleting twice deletes once and then answers 404.
+export const PurgeFlowInput = z.strictObject({
+    flowId: IntelId.describe("Flow to delete for good. It must already be archived — a living flow has no path into nothing."),
+});
+export const PurgeFlowResult = z.strictObject({
+    purged: z.literal(true),
+    title: z.string(),
+});
 // Three answers, not two: an absent `parentId` lists every visible flow (the search dialog asks
 // that), `null` lists the root of the shared tree and an ID lists one folder (the sidebar tree asks
 // per level, which is what keeps the tree off the N+1 it used to load with).

package/dist/contract/node.d.ts

@@ -105,6 +105,15 @@ export declare const ArchiveNodeInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type ArchiveNodeInput = z.infer<typeof ArchiveNodeInput>;
+export declare const PurgeNodeInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodeInput = z.infer<typeof PurgeNodeInput>;
+export declare const PurgeNodeResult: z.ZodObject<{
+    purged: z.ZodLiteral<true>;
+    title: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodeResult = z.infer<typeof PurgeNodeResult>;
 export declare const NodeList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;

package/dist/contract/node.js

@@ -181,6 +181,24 @@ export const ArchiveNodeInput = z.strictObject({
         .describe("`true` archives the node, `false` restores it. Archiving hides a node from listings and search; nothing is deleted and every version stays readable."),
     idempotencyKey: IdempotencyKey,
 });
+// ⚠️ The one input in this contract that describes an IRREVERSIBLE act (#457). Everything else
+// called "delete" in Intel means `archived_at`.
+//
+// It carries no `baseUpdatedAt` and no `idempotencyKey`, and both absences are decisions:
+//   · There is nothing to conflict with. The node must already be archived — an archived node is
+//     not being edited by anybody, and a restore between the read and the call is caught by the
+//     statement itself rather than by a timestamp the caller had to carry.
+//   · A replay has nothing to replay. Deleting twice is deleting once and then a 404, which is the
+//     honest answer: the second caller really did not delete anything.
+export const PurgeNodeInput = z.strictObject({
+    nodeId: IntelId.describe("Node to delete for good. It must already be archived — a living node has no path into nothing."),
+});
+// The title travels back because after this call nothing can look it up any more — not the row, not
+// a version, not the index. A caller that wants to say what it just deleted has this one chance.
+export const PurgeNodeResult = z.strictObject({
+    purged: z.literal(true),
+    title: z.string(),
+});
 // ⚠️ `withChildren` belongs to the LEVEL, not to the node (#59). Whether something has children
 // THIS reader may see is not a property of the thing — two readers get different answers. As a
 // field on the node, every other place that returns a node would have to compute it as well or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-contract",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {