@kubun/mutation 0.16.0 → 0.17.1

package/lib/create.d.ts

@@ -1,7 +1,6 @@
-import type { PatchOperation } from '@kubun/graphql';
 import { HLC } from '@kubun/hlc';
 import { DocumentID, type DocumentModelID } from '@kubun/id';
-import type { ChangeDocumentMutation, DocumentData, SetDocumentMutation } from '@kubun/protocol';
+import type { ChangeDocumentMutation, DocumentData, PatchOperation, SetDocumentMutation, TombstoneDocumentMutation } from '@kubun/protocol';
 export type CreateSetMutationParams<Data extends DocumentData = DocumentData> = {
     data: Data;
     hlc: HLC;
@@ -10,6 +9,7 @@ export type CreateSetMutationParams<Data extends DocumentData = DocumentData> =
     owner?: string;
     unique: Uint8Array;
     cap?: string | Array<string>;
+    sourceFetchHLC?: string;
 };
 export declare function createSetMutation<Data extends DocumentData = DocumentData>(params: CreateSetMutationParams<Data>): Promise<SetDocumentMutation>;
 export type CreateChangeMutationParams = {
@@ -27,3 +27,13 @@ export type CreateRemoveMutationParams = {
     cap?: string | Array<string>;
 };
 export declare function createRemoveMutation(params: CreateRemoveMutationParams): ChangeDocumentMutation;
+export type CreateTombstoneMutationParams = {
+    hlc: HLC;
+    issuer: string;
+    modelID: DocumentModelID | string;
+    owner?: string;
+    unique: Uint8Array;
+    sourceFetchHLC: string;
+    cap?: string | Array<string>;
+};
+export declare function createTombstoneMutation(params: CreateTombstoneMutationParams): Promise<TombstoneDocumentMutation>;

package/lib/create.js

@@ -2,7 +2,7 @@ import { HLC } from '@kubun/hlc';
 import { DocumentID } from '@kubun/id';
 import { isValidAccessPermissions } from '@kubun/protocol';
 import { toB64 } from '@sozai/codec';
-import { InvalidAccessPermissionsError } from './errors.js';
+import { FetchTokenOrderError, InvalidAccessPermissionsError } from './errors.js';
 const ACCESS_PERMISSIONS_FIELD = 'accessPermissions';
 const ACCESS_PERMISSIONS_PATH = `/${ACCESS_PERMISSIONS_FIELD}`;
 /**
@@ -30,16 +30,23 @@ export async function createSetMutation(params) {
     const issuer = params.issuer;
     const owner = params.owner ?? issuer;
     const docID = await DocumentID.create(params.modelID, owner, params.unique);
+    const hlc = HLC.serialize(params.hlc.now());
+    if (params.sourceFetchHLC != null && hlc < params.sourceFetchHLC) {
+        throw new FetchTokenOrderError();
+    }
     return {
         typ: 'set',
         iss: issuer,
         aud: owner,
         sub: docID.toString(),
         data: params.data,
-        hlc: HLC.serialize(params.hlc.now()),
+        hlc,
         unq: toB64(params.unique),
         ...params.cap != null ? {
             cap: params.cap
+        } : {},
+        ...params.sourceFetchHLC != null ? {
+            sourceFetchHLC: params.sourceFetchHLC
         } : {}
     };
 }
@@ -74,3 +81,23 @@ export function createRemoveMutation(params) {
         } : {}
     };
 }
+export async function createTombstoneMutation(params) {
+    const owner = params.owner ?? params.issuer;
+    const docID = await DocumentID.create(params.modelID, owner, params.unique);
+    const hlc = HLC.serialize(params.hlc.now());
+    if (hlc < params.sourceFetchHLC) {
+        throw new FetchTokenOrderError();
+    }
+    return {
+        typ: 'tombstone',
+        iss: params.issuer,
+        aud: owner,
+        sub: docID.toString(),
+        unq: toB64(params.unique),
+        hlc,
+        sourceFetchHLC: params.sourceFetchHLC,
+        ...params.cap != null ? {
+            cap: params.cap
+        } : {}
+    };
+}

package/lib/errors.d.ts

@@ -39,6 +39,109 @@ export declare class HLCDriftError extends Error {
     get driftMS(): number;
     get maxDriftMS(): number;
 }
+/**
+ * Thrown when a fetch token cannot be parsed as a valid HLC timestamp. Detects
+ * malformed tokens or NaN values that would slip past `HLC.parse` but fail
+ * `HLC.tryParse` validation. Tagged `KB16` so the RPC handler can translate the
+ * throw into a structured wire response.
+ */
+export declare class InvalidFetchTokenError extends Error {
+    #private;
+    constructor(token: string);
+    get code(): 'KB16';
+    get token(): string;
+}
+/**
+ * Thrown when a mutation's minted HLC timestamp predates the supplied fetch
+ * token (sourceFetchHLC). Since HLC is a fixed property of a signed mutation,
+ * this reject is permanent — resending cannot move the HLC forward. Tagged
+ * `KB17` so the RPC handler can translate the throw into a structured wire
+ * response.
+ */
+export declare class FetchTokenOrderError extends Error {
+    constructor();
+    get code(): 'KB17';
+}
+/**
+ * Thrown by the set apply path when a merge-policy SET omits a schema-required
+ * field of its model's provider group. A merge-policy SET must carry the
+ * complete group so a winning higher-key SET can atomically replace it (an
+ * omitted OPTIONAL group field is legitimate — it clears that field's stored
+ * value instead of throwing). Tagged `KB18` so the RPC handler can translate
+ * the throw into a structured wire response.
+ */
+export declare class IncompleteProviderGroupError extends Error {
+    #private;
+    constructor(docID: string, field: string);
+    get code(): 'KB18';
+    get docID(): string;
+    get field(): string;
+}
+/**
+ * Thrown by the tombstone apply path when the target document's model
+ * declares no `providerMergePolicy`. A tombstone advances the fetch-order
+ * `/fetch` liveness register, which only a merge-policy document's `assemble`
+ * consults — an ordinary model's liveness is governed by the plain `$set`/`/`
+ * HLC registers and deletes via the `/`→null CHANGE path instead. Tagged
+ * `KB19` so the RPC handler can translate the throw into a structured wire
+ * response.
+ */
+export declare class TombstoneRequiresMergePolicyError extends Error {
+    #private;
+    constructor(docID: string);
+    get code(): 'KB19';
+    get docID(): string;
+}
+/**
+ * Thrown by the change apply path when a CHANGE mutation targets a
+ * merge-policy model's provider-authoritative group. The group is single
+ * authority — every write to it is a fetch-token-ordered provider projection
+ * (a complete-group SET or a tombstone) — so a local HLC-ordered CHANGE
+ * against it would mix two incompatible orderings on the same fields. A
+ * CHANGE to a field outside the group is unaffected. Tagged `KB20` so the RPC
+ * handler can translate the throw into a structured wire response.
+ */
+export declare class ProviderGroupChangeRejectedError extends Error {
+    #private;
+    constructor(docID: string, field: string);
+    get code(): 'KB20';
+    get docID(): string;
+    get field(): string;
+}
+/**
+ * Thrown by the set and tombstone apply paths when a merge-policy model's
+ * single-authority write carries no `sourceFetchHLC`. No conforming producer
+ * emits a tokenless merge-policy write — `createSetMutation`/
+ * `createTombstoneMutation` mint one, and the tombstone wire schema requires
+ * it — so this is a defensive gate: it keeps the incoming token always
+ * present by the time a merge-policy candidate reaches classification. Tagged
+ * `KB21` so the RPC handler can translate the throw into a structured wire
+ * response.
+ */
+export declare class MissingFetchTokenError extends Error {
+    #private;
+    constructor(docID: string);
+    get code(): 'KB21';
+    get docID(): string;
+}
+/**
+ * Thrown by the change apply path when a generic `/`→null delete CHANGE targets
+ * a merge-policy model. A merge-policy document's liveness lives in the
+ * fetch-order registers (`$setFetch`/`/fetch`), which a delete CHANGE never
+ * advances — it would null the visible data while leaving the live register
+ * standing, so a later provider SET or any outside-group CHANGE would resurrect
+ * the document with stale group data. Such a deletion must flow through the
+ * fetch-token tombstone path instead, which carries the token that advances
+ * `/fetch`. The rejection is deterministic and permanent — the same mutation
+ * always fails. Tagged `KB22` so the RPC handler can translate the throw into a
+ * structured wire response.
+ */
+export declare class MergePolicyRemoveRequiresTombstoneError extends Error {
+    #private;
+    constructor(docID: string);
+    get code(): 'KB22';
+    get docID(): string;
+}
 /**
  * Thrown by the set apply path when a mutation would reassign an existing
  * document's owner. Ownership is immutable once a document exists, so this is a

package/lib/errors.js

@@ -64,6 +64,163 @@
         return this.#maxDriftMS;
     }
 }
+/**
+ * Thrown when a fetch token cannot be parsed as a valid HLC timestamp. Detects
+ * malformed tokens or NaN values that would slip past `HLC.parse` but fail
+ * `HLC.tryParse` validation. Tagged `KB16` so the RPC handler can translate the
+ * throw into a structured wire response.
+ */ export class InvalidFetchTokenError extends Error {
+    #token;
+    constructor(token){
+        super(`Invalid fetch token: malformed HLC timestamp '${token}'`);
+        this.name = 'InvalidFetchTokenError';
+        this.#token = token;
+    }
+    get code() {
+        return 'KB16';
+    }
+    get token() {
+        return this.#token;
+    }
+}
+/**
+ * Thrown when a mutation's minted HLC timestamp predates the supplied fetch
+ * token (sourceFetchHLC). Since HLC is a fixed property of a signed mutation,
+ * this reject is permanent — resending cannot move the HLC forward. Tagged
+ * `KB17` so the RPC handler can translate the throw into a structured wire
+ * response.
+ */ export class FetchTokenOrderError extends Error {
+    constructor(){
+        super('Fetch token ordering violated: mutation HLC must be >= sourceFetchHLC');
+        this.name = 'FetchTokenOrderError';
+    }
+    get code() {
+        return 'KB17';
+    }
+}
+/**
+ * Thrown by the set apply path when a merge-policy SET omits a schema-required
+ * field of its model's provider group. A merge-policy SET must carry the
+ * complete group so a winning higher-key SET can atomically replace it (an
+ * omitted OPTIONAL group field is legitimate — it clears that field's stored
+ * value instead of throwing). Tagged `KB18` so the RPC handler can translate
+ * the throw into a structured wire response.
+ */ export class IncompleteProviderGroupError extends Error {
+    #docID;
+    #field;
+    constructor(docID, field){
+        super(`Incomplete provider group: document ${docID} SET omits required field '${field}'`);
+        this.name = 'IncompleteProviderGroupError';
+        this.#docID = docID;
+        this.#field = field;
+    }
+    get code() {
+        return 'KB18';
+    }
+    get docID() {
+        return this.#docID;
+    }
+    get field() {
+        return this.#field;
+    }
+}
+/**
+ * Thrown by the tombstone apply path when the target document's model
+ * declares no `providerMergePolicy`. A tombstone advances the fetch-order
+ * `/fetch` liveness register, which only a merge-policy document's `assemble`
+ * consults — an ordinary model's liveness is governed by the plain `$set`/`/`
+ * HLC registers and deletes via the `/`→null CHANGE path instead. Tagged
+ * `KB19` so the RPC handler can translate the throw into a structured wire
+ * response.
+ */ export class TombstoneRequiresMergePolicyError extends Error {
+    #docID;
+    constructor(docID){
+        super(`Tombstone requires a provider-merge-policy model: document ${docID}`);
+        this.name = 'TombstoneRequiresMergePolicyError';
+        this.#docID = docID;
+    }
+    get code() {
+        return 'KB19';
+    }
+    get docID() {
+        return this.#docID;
+    }
+}
+/**
+ * Thrown by the change apply path when a CHANGE mutation targets a
+ * merge-policy model's provider-authoritative group. The group is single
+ * authority — every write to it is a fetch-token-ordered provider projection
+ * (a complete-group SET or a tombstone) — so a local HLC-ordered CHANGE
+ * against it would mix two incompatible orderings on the same fields. A
+ * CHANGE to a field outside the group is unaffected. Tagged `KB20` so the RPC
+ * handler can translate the throw into a structured wire response.
+ */ export class ProviderGroupChangeRejectedError extends Error {
+    #docID;
+    #field;
+    constructor(docID, field){
+        super(`Provider group CHANGE rejected: document ${docID} CHANGE targets provider group field '${field}'`);
+        this.name = 'ProviderGroupChangeRejectedError';
+        this.#docID = docID;
+        this.#field = field;
+    }
+    get code() {
+        return 'KB20';
+    }
+    get docID() {
+        return this.#docID;
+    }
+    get field() {
+        return this.#field;
+    }
+}
+/**
+ * Thrown by the set and tombstone apply paths when a merge-policy model's
+ * single-authority write carries no `sourceFetchHLC`. No conforming producer
+ * emits a tokenless merge-policy write — `createSetMutation`/
+ * `createTombstoneMutation` mint one, and the tombstone wire schema requires
+ * it — so this is a defensive gate: it keeps the incoming token always
+ * present by the time a merge-policy candidate reaches classification. Tagged
+ * `KB21` so the RPC handler can translate the throw into a structured wire
+ * response.
+ */ export class MissingFetchTokenError extends Error {
+    #docID;
+    constructor(docID){
+        super(`Missing fetch token: document ${docID} merge-policy write carries no sourceFetchHLC`);
+        this.name = 'MissingFetchTokenError';
+        this.#docID = docID;
+    }
+    get code() {
+        return 'KB21';
+    }
+    get docID() {
+        return this.#docID;
+    }
+}
+/**
+ * Thrown by the change apply path when a generic `/`→null delete CHANGE targets
+ * a merge-policy model. A merge-policy document's liveness lives in the
+ * fetch-order registers (`$setFetch`/`/fetch`), which a delete CHANGE never
+ * advances — it would null the visible data while leaving the live register
+ * standing, so a later provider SET or any outside-group CHANGE would resurrect
+ * the document with stale group data. Such a deletion must flow through the
+ * fetch-token tombstone path instead, which carries the token that advances
+ * `/fetch`. The rejection is deterministic and permanent — the same mutation
+ * always fails. Tagged `KB22` so the RPC handler can translate the throw into a
+ * structured wire response.
+ */ export class MergePolicyRemoveRequiresTombstoneError extends Error {
+    #docID;
+    constructor(docID){
+        super(`Merge-policy remove requires a tombstone: document ${docID} must be deleted via the fetch-token tombstone path`);
+        this.name = 'MergePolicyRemoveRequiresTombstoneError';
+        this.#docID = docID;
+    }
+    get code() {
+        return 'KB22';
+    }
+    get docID() {
+        return this.#docID;
+    }
+}
 /**
  * Thrown by the set apply path when a mutation would reassign an existing
  * document's owner. Ownership is immutable once a document exists, so this is a
@@ -142,7 +299,14 @@ const PERMANENT_APPLY_ERROR_CODES = new Set([
     'KB10',
     'KB11',
     'KB12',
-    'KB13'
+    'KB13',
+    'KB16',
+    'KB17',
+    'KB18',
+    'KB19',
+    'KB20',
+    'KB21',
+    'KB22'
 ]);
 /**
  * True when `err` carries a protocol error code identifying a deterministically

package/lib/index.d.ts

@@ -1,8 +1,9 @@
 export { HLC, type HLCTimestamp } from '@kubun/hlc';
-export type { DocumentValidator, MutationContext, MutationDB, PostStateGate, ValidatorsRecord, } from './apply.js';
-export { applyChangeMutation, applyMutation, applySetMutation, DEFAULT_MAX_DRIFT_MS, getTopLevelField, } from './apply.js';
-export type { CreateChangeMutationParams, CreateRemoveMutationParams, CreateSetMutationParams, } from './create.js';
-export { createChangeMutation, createRemoveMutation, createSetMutation } from './create.js';
-export { DocumentIDMismatchError, HLCDriftError, InvalidAccessPermissionsError, isPermanentApplyError, MutationSchemaValidationError, OwnerChangeError, UnsupportedMutationTypeError, WriteAccessDeniedError, } from './errors.js';
+export type { DocumentValidator, FetchFrontier, MergeOutcome, MutationApplyResult, MutationContext, MutationDB, PostStateGate, ValidatorsRecord, } from './apply.js';
+export { applyChangeMutation, applyMutation, applySetMutation, applyTombstoneMutation, classifySetOutcome, classifyTombstoneOutcome, DEFAULT_MAX_DRIFT_MS, DELETE_FETCH_KEY, getTopLevelField, resolveModelPolicy, SET_FETCH_KEY, validateFetchTokenDrift, winnerStateDigestOf, } from './apply.js';
+export type { CreateChangeMutationParams, CreateRemoveMutationParams, CreateSetMutationParams, CreateTombstoneMutationParams, } from './create.js';
+export { createChangeMutation, createRemoveMutation, createSetMutation, createTombstoneMutation, } from './create.js';
+export { DocumentIDMismatchError, FetchTokenOrderError, HLCDriftError, IncompleteProviderGroupError, InvalidAccessPermissionsError, InvalidFetchTokenError, isPermanentApplyError, MergePolicyRemoveRequiresTombstoneError, MissingFetchTokenError, MutationSchemaValidationError, OwnerChangeError, ProviderGroupChangeRejectedError, TombstoneRequiresMergePolicyError, UnsupportedMutationTypeError, WriteAccessDeniedError, } from './errors.js';
 export type { CreateDocumentParams, CreateMutationOperationsParams, MutationOperations, RemoveDocumentParams, SetDocumentParams, UpdateDocumentParams, } from './operations.js';
 export { convertPatchInput, createMutationOperations } from './operations.js';
+export { DELETED_STATE_DIGEST, type StateDigestInput, stateDigest } from './state-digest.js';

package/lib/index.js

@@ -1,5 +1,6 @@
 export { HLC } from '@kubun/hlc';
-export { applyChangeMutation, applyMutation, applySetMutation, DEFAULT_MAX_DRIFT_MS, getTopLevelField } from './apply.js';
-export { createChangeMutation, createRemoveMutation, createSetMutation } from './create.js';
-export { DocumentIDMismatchError, HLCDriftError, InvalidAccessPermissionsError, isPermanentApplyError, MutationSchemaValidationError, OwnerChangeError, UnsupportedMutationTypeError, WriteAccessDeniedError } from './errors.js';
+export { applyChangeMutation, applyMutation, applySetMutation, applyTombstoneMutation, classifySetOutcome, classifyTombstoneOutcome, DEFAULT_MAX_DRIFT_MS, DELETE_FETCH_KEY, getTopLevelField, resolveModelPolicy, SET_FETCH_KEY, validateFetchTokenDrift, winnerStateDigestOf } from './apply.js';
+export { createChangeMutation, createRemoveMutation, createSetMutation, createTombstoneMutation } from './create.js';
+export { DocumentIDMismatchError, FetchTokenOrderError, HLCDriftError, IncompleteProviderGroupError, InvalidAccessPermissionsError, InvalidFetchTokenError, isPermanentApplyError, MergePolicyRemoveRequiresTombstoneError, MissingFetchTokenError, MutationSchemaValidationError, OwnerChangeError, ProviderGroupChangeRejectedError, TombstoneRequiresMergePolicyError, UnsupportedMutationTypeError, WriteAccessDeniedError } from './errors.js';
 export { convertPatchInput, createMutationOperations } from './operations.js';
+export { DELETED_STATE_DIGEST, stateDigest } from './state-digest.js';

package/lib/operations.d.ts

@@ -1,6 +1,5 @@
-import type { PatchOperation } from '@kubun/graphql';
 import type { HLC } from '@kubun/hlc';
-import type { ChangeDocumentMutation, DocumentData, SetDocumentMutation } from '@kubun/protocol';
+import type { ChangeDocumentMutation, DocumentData, PatchOperation, SetDocumentMutation, TombstoneDocumentMutation } from '@kubun/protocol';
 import type { GetRandomValues } from '@sozai/runtime';
 export type CreateMutationOperationsParams<T> = {
     issuer: string;
@@ -10,6 +9,7 @@ export type CreateMutationOperationsParams<T> = {
     cap?: string | Array<string>;
     processSetMutation(mutation: SetDocumentMutation, transactionID?: string | null): Promise<T>;
     processChangeMutation(mutation: ChangeDocumentMutation, transactionID?: string | null): Promise<T>;
+    processTombstoneMutation?(mutation: TombstoneDocumentMutation, transactionID?: string | null): Promise<T>;
 };
 export type CreateDocumentParams = {
     modelID: string;
@@ -31,6 +31,7 @@ export type SetDocumentParams = {
      * Omitted means owner = the ops-level owner (or the signer when unset).
      */
     owner?: string;
+    sourceFetchHLC?: string;
 };
 export type UpdateDocumentParams = {
     docID: string;
@@ -41,11 +42,23 @@ export type RemoveDocumentParams = {
     docID: string;
     transactionID?: string | null;
 };
+export type TombstoneDocumentParams = {
+    modelID: string;
+    unique: Uint8Array;
+    sourceFetchHLC: string;
+    transactionID?: string | null;
+    /**
+     * Per-call document owner, overriding the ops-level owner for this write only.
+     * Omitted means owner = the ops-level owner (or the signer when unset).
+     */
+    owner?: string;
+};
 export type MutationOperations<T> = {
     createDocument(params: CreateDocumentParams): Promise<T>;
     setDocument(params: SetDocumentParams): Promise<T>;
     updateDocument(params: UpdateDocumentParams): Promise<T>;
     removeDocument(params: RemoveDocumentParams): Promise<T>;
+    tombstoneDocument(params: TombstoneDocumentParams): Promise<T>;
 };
 export declare function createMutationOperations<T>(params: CreateMutationOperationsParams<T>): MutationOperations<T>;
 export declare function convertPatchInput(patch: Array<Record<string, unknown>>): Array<PatchOperation>;

package/lib/operations.js

@@ -1,6 +1,6 @@
-import { createChangeMutation, createRemoveMutation, createSetMutation } from './create.js';
+import { createChangeMutation, createRemoveMutation, createSetMutation, createTombstoneMutation } from './create.js';
 export function createMutationOperations(params) {
-    const { issuer, hlc, getRandomValues, owner, cap, processSetMutation, processChangeMutation } = params;
+    const { issuer, hlc, getRandomValues, owner, cap, processSetMutation, processChangeMutation, processTombstoneMutation } = params;
     return {
         async createDocument (params) {
             const { modelID, data, transactionID } = params;
@@ -17,7 +17,7 @@ export function createMutationOperations(params) {
             return await processSetMutation(mutation, transactionID);
         },
         async setDocument (params) {
-            const { modelID, unique, data, transactionID } = params;
+            const { modelID, unique, data, transactionID, sourceFetchHLC } = params;
             const mutation = await createSetMutation({
                 issuer,
                 hlc,
@@ -25,7 +25,8 @@ export function createMutationOperations(params) {
                 data,
                 unique,
                 owner: params.owner ?? owner,
-                cap
+                cap,
+                sourceFetchHLC
             });
             return await processSetMutation(mutation, transactionID);
         },
@@ -47,6 +48,22 @@ export function createMutationOperations(params) {
                 cap
             });
             return await processChangeMutation(mutation, transactionID);
+        },
+        async tombstoneDocument (params) {
+            if (processTombstoneMutation == null) {
+                throw new Error('tombstoneDocument requires processTombstoneMutation');
+            }
+            const { modelID, unique, sourceFetchHLC, transactionID } = params;
+            const mutation = await createTombstoneMutation({
+                issuer,
+                hlc,
+                modelID,
+                unique,
+                owner: params.owner ?? owner,
+                cap,
+                sourceFetchHLC
+            });
+            return await processTombstoneMutation(mutation, transactionID);
         }
     };
 }

package/lib/state-digest.d.ts

@@ -0,0 +1,16 @@
+/** The candidate's state, folded into one BLAKE3 digest with a liveness marker. */
+export type StateDigestInput = {
+    state: 'live';
+    group: Record<string, unknown>;
+} | {
+    state: 'deleted';
+};
+/**
+ * The candidate's state digest as a base64url (no padding) string. One
+ * definition serves the equal-token tiebreak, the `$setFetch`/`/fetch`
+ * registers, the watch watermarks, and the seam's candidate/winner digests.
+ * `group` excludes the fetch token, the digest itself, and every
+ * local-annotation field.
+ */
+export declare function stateDigest(input: StateDigestInput): string;
+export declare const DELETED_STATE_DIGEST: string;

package/lib/state-digest.js

@@ -0,0 +1,21 @@
+import { digestJSON } from '@kubun/id';
+import { toB64U } from '@sozai/codec';
+/**
+ * The candidate's state digest as a base64url (no padding) string. One
+ * definition serves the equal-token tiebreak, the `$setFetch`/`/fetch`
+ * registers, the watch watermarks, and the seam's candidate/winner digests.
+ * `group` excludes the fetch token, the digest itself, and every
+ * local-annotation field.
+ */ export function stateDigest(input) {
+    const canonical = input.state === 'live' ? {
+        state: 'live',
+        group: input.group
+    } : {
+        state: 'deleted'
+    };
+    const bytes = digestJSON(canonical);
+    return toB64U(bytes);
+}
+export const DELETED_STATE_DIGEST = stateDigest({
+    state: 'deleted'
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/mutation",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,16 +15,15 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@kubun/hlc": "^0.16.0",
-    "@kubun/id": "^0.16.0",
+    "@kubun/hlc": "^0.17.0",
+    "@kubun/id": "^0.17.0",
     "@sozai/codec": "^0.4.0",
     "@sozai/patch": "^0.1.3",
     "@sozai/runtime": "^0.1.0",
     "@sozai/schema": "^0.1.2"
   },
   "devDependencies": {
-    "@kubun/graphql": "^0.16.0",
-    "@kubun/protocol": "^0.16.0"
+    "@kubun/protocol": "^0.17.1"
   },
   "publishConfig": {
     "access": "public"
@@ -32,8 +31,8 @@
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
-    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:js": "del 'lib/**/*.js' && swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "del 'lib/**/*.d.ts' 'lib/**/*.d.ts.map' && tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
     "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",