@kubun/id 0.11.0 → 0.13.0

package/lib/attachment.d.ts

@@ -1,5 +1,5 @@
-import { AttachmentType, KubunID } from './base.js';
-export declare class AttachmentID extends KubunID<AttachmentType.BINARY> {
+import { ATTACHMENT_BINARY, KubunID } from './base.js';
+export declare class AttachmentID extends KubunID<typeof ATTACHMENT_BINARY> {
     #private;
     static create(value: Uint8Array, mimeType?: string): AttachmentID;
     static fromBytes(input: Uint8Array): AttachmentID;

package/lib/attachment.js

@@ -1,6 +1,6 @@
 import { fromUTF, toUTF } from '@sozai/codec';
 import { base36 } from 'multiformats/bases/base36';
-import { AttachmentType, KubunID, NAMESPACE_CODE } from './base.js';
+import { ATTACHMENT_BINARY, KubunID, NAMESPACE_CODE } from './base.js';
 import { concat } from './bytes.js';
 import { decodeVarint, digestBytes, encodeVarint } from './utils.js';
 const DEFAULT_MIME_TYPE = 'application/octet-stream';
@@ -18,7 +18,7 @@ export class AttachmentID extends KubunID {
         offset += namespaceLength;
         // Check type matches
         const [type, typeLength] = decodeVarint(input, offset);
-        if (type !== AttachmentType.BINARY) {
+        if (type !== ATTACHMENT_BINARY) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         offset += typeLength;
@@ -79,7 +79,7 @@ export class AttachmentID extends KubunID {
                 typeBytes
             ]);
         }
-        super(AttachmentType.BINARY, data);
+        super(ATTACHMENT_BINARY, data);
         this.#contentLength = contentLength;
         this.#digest = digest;
         this.#mimeType = mimeType;

package/lib/base.d.ts

@@ -1,20 +1,28 @@
 export declare const NAMESPACE_CODE = 181;
-export declare enum AttachmentType {
-    BINARY = 1
-}
-export declare enum ModelType {
-    SCALAR = 10,
-    SHAPE = 11,
-    DOCUMENT = 20,
-    CLUSTER = 21
-}
-export declare enum DocumentType {
-    MERGE_DOCUMENT = 30
-}
-export declare enum ExternalType {
-    PLUGIN_NODE = 40
-}
-export type KubunType = AttachmentType | ModelType | DocumentType | ExternalType;
+/**
+ * Immutable references
+ */
+export declare const ATTACHMENT_BINARY = 1;
+export type AttachmentType = typeof ATTACHMENT_BINARY;
+export declare const MODEL_SCALAR = 10;
+export declare const MODEL_SHAPE = 11;
+export declare const MODEL_DOCUMENT = 20;
+export declare const MODEL_CLUSTER = 21;
+export type ModelType = typeof MODEL_SCALAR | typeof MODEL_SHAPE | typeof MODEL_DOCUMENT | typeof MODEL_CLUSTER;
+/**
+ * Mutable references
+ */
+export declare const DOCUMENT_MERGE = 30;
+export type DocumentType = typeof DOCUMENT_MERGE;
+export declare const CREDENTIAL_KEY = 31;
+export declare const CREDENTIAL_ENTRY = 32;
+export type CredentialType = typeof CREDENTIAL_KEY | typeof CREDENTIAL_ENTRY;
+/**
+ * External references
+ */
+export declare const EXTERNAL_PLUGIN_NODE = 40;
+export type ExternalType = typeof EXTERNAL_PLUGIN_NODE;
+export type KubunType = AttachmentType | ModelType | DocumentType | CredentialType | ExternalType;
 export declare class KubunID<T extends KubunType = KubunType> {
     #private;
     constructor(type: T, dataBytes: Uint8Array);

package/lib/base.js

@@ -3,30 +3,23 @@ import { concat, equals } from './bytes.js';
 import { encodeVarint } from './utils.js';
 export const NAMESPACE_CODE = 0xb5;
 const NAMESPACE_BYTES = encodeVarint(NAMESPACE_CODE);
-// Immutable
-export var AttachmentType = /*#__PURE__*/ function(AttachmentType) {
-    AttachmentType[AttachmentType["BINARY"] = 1] = "BINARY";
-    return AttachmentType;
-}({});
-export var ModelType = /*#__PURE__*/ function(ModelType) {
-    // DAG-only
-    ModelType[ModelType["SCALAR"] = 10] = "SCALAR";
-    ModelType[ModelType["SHAPE"] = 11] = "SHAPE";
-    // Circular
-    ModelType[ModelType["DOCUMENT"] = 20] = "DOCUMENT";
-    ModelType[ModelType["CLUSTER"] = 21] = "CLUSTER";
-    return ModelType;
-}({});
-// Mutable
-export var DocumentType = /*#__PURE__*/ function(DocumentType) {
-    DocumentType[DocumentType["MERGE_DOCUMENT"] = 30] = "MERGE_DOCUMENT";
-    return DocumentType;
-}({});
-// External
-export var ExternalType = /*#__PURE__*/ function(ExternalType) {
-    ExternalType[ExternalType["PLUGIN_NODE"] = 40] = "PLUGIN_NODE";
-    return ExternalType;
-}({});
+/**
+ * Immutable references
+ */ export const ATTACHMENT_BINARY = 1;
+// DAG-only
+export const MODEL_SCALAR = 10;
+export const MODEL_SHAPE = 11;
+// Circular
+export const MODEL_DOCUMENT = 20;
+export const MODEL_CLUSTER = 21;
+/**
+ * Mutable references
+ */ export const DOCUMENT_MERGE = 30;
+export const CREDENTIAL_KEY = 31;
+export const CREDENTIAL_ENTRY = 32;
+/**
+ * External references
+ */ export const EXTERNAL_PLUGIN_NODE = 40;
 export class KubunID {
     #type;
     #dataBytes;

package/lib/bytes.d.ts

@@ -1,2 +1,2 @@
-export declare function concat(arrays: Uint8Array[], providedLength?: number): Uint8Array;
+export declare function concat(arrays: Array<Uint8Array>, providedLength?: number): Uint8Array;
 export declare function equals(a: Uint8Array, b: Uint8Array): boolean;

package/lib/cluster-model.d.ts

@@ -1,5 +1,5 @@
-import { KubunID, ModelType } from './base.js';
-export declare class ClusterModelID extends KubunID<ModelType.CLUSTER> {
+import { KubunID, MODEL_CLUSTER } from './base.js';
+export declare class ClusterModelID extends KubunID<typeof MODEL_CLUSTER> {
     static fromDigest(digestBytes: Uint8Array): ClusterModelID;
     static fromBytes(input: Uint8Array): ClusterModelID;
     static fromString(input: string): ClusterModelID;

package/lib/cluster-model.js

@@ -1,5 +1,5 @@
 import { base36 } from 'multiformats/bases/base36';
-import { KubunID, ModelType, NAMESPACE_CODE } from './base.js';
+import { KubunID, MODEL_CLUSTER, NAMESPACE_CODE } from './base.js';
 import { decodeVarint } from './utils.js';
 export class ClusterModelID extends KubunID {
     static fromDigest(digestBytes) {
@@ -11,7 +11,7 @@ export class ClusterModelID extends KubunID {
             throw new Error('Invalid KubunID: namespace mismatch');
         }
         const [type, typeLength] = decodeVarint(input, namespaceLength);
-        if (type !== ModelType.CLUSTER) {
+        if (type !== MODEL_CLUSTER) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         const digestBytes = input.slice(namespaceLength + typeLength);
@@ -21,6 +21,6 @@ export class ClusterModelID extends KubunID {
         return ClusterModelID.fromBytes(base36.decode(input));
     }
     constructor(digestBytes){
-        super(ModelType.CLUSTER, digestBytes);
+        super(MODEL_CLUSTER, digestBytes);
     }
 }

package/lib/credential.d.ts

@@ -0,0 +1,34 @@
+import { CREDENTIAL_ENTRY, CREDENTIAL_KEY, KubunID } from './base.js';
+/**
+ * A credential key: the unit a wrapping addresses, a grant shares and a rotation
+ * bumps.
+ *
+ * Not content-addressed. Rotation preserves the id and moves `version`, so a
+ * document referencing a key keeps referencing it across rotations — which is
+ * the whole reason rotation does not mint a new id.
+ */
+export declare class CredentialKeyID extends KubunID<typeof CREDENTIAL_KEY> {
+    #private;
+    static create(owner: string | Uint8Array, unique: Uint8Array): CredentialKeyID;
+    static fromBytes(input: Uint8Array): CredentialKeyID;
+    static fromString(input: string): CredentialKeyID;
+    static from(input: CredentialKeyID | Uint8Array | string): CredentialKeyID;
+    constructor(digest: Uint8Array);
+    get digest(): Uint8Array;
+}
+/**
+ * A credential entry: one encrypted value under a key.
+ *
+ * Does not embed its key's id. An entry can be re-keyed without every document
+ * that references it changing, and its value changes — a refreshed OAuth token —
+ * without the reference changing either.
+ */
+export declare class CredentialEntryID extends KubunID<typeof CREDENTIAL_ENTRY> {
+    #private;
+    static create(owner: string | Uint8Array, unique: Uint8Array): CredentialEntryID;
+    static fromBytes(input: Uint8Array): CredentialEntryID;
+    static fromString(input: string): CredentialEntryID;
+    static from(input: CredentialEntryID | Uint8Array | string): CredentialEntryID;
+    constructor(digest: Uint8Array);
+    get digest(): Uint8Array;
+}

package/lib/credential.js

@@ -0,0 +1,110 @@
+import { fromUTF } from '@sozai/codec';
+import { base36 } from 'multiformats/bases/base36';
+import { CREDENTIAL_ENTRY, CREDENTIAL_KEY, KubunID, NAMESPACE_CODE } from './base.js';
+import { concat } from './bytes.js';
+import { decodeVarint, digestBytes, encodeVarint } from './utils.js';
+function encodeData(digest) {
+    return concat([
+        encodeVarint(digest.byteLength),
+        digest
+    ]);
+}
+function decodeDigest(input, expected) {
+    let offset = 0;
+    // Check namespace = is it a KubunID?
+    const [namespace, namespaceLength] = decodeVarint(input);
+    if (namespace !== NAMESPACE_CODE) {
+        throw new Error('Invalid KubunID: namespace mismatch');
+    }
+    offset += namespaceLength;
+    // Check type matches
+    const [type, typeLength] = decodeVarint(input, offset);
+    if (type !== expected) {
+        throw new Error('Invalid KubunID: type mismatch');
+    }
+    offset += typeLength;
+    const [digestLength, digestVarintLength] = decodeVarint(input, offset);
+    offset += digestVarintLength;
+    return input.slice(offset, offset + digestLength);
+}
+function createDigest(owner, unique) {
+    return digestBytes(concat([
+        typeof owner === 'string' ? fromUTF(owner) : owner,
+        unique
+    ]));
+}
+/**
+ * A credential key: the unit a wrapping addresses, a grant shares and a rotation
+ * bumps.
+ *
+ * Not content-addressed. Rotation preserves the id and moves `version`, so a
+ * document referencing a key keeps referencing it across rotations — which is
+ * the whole reason rotation does not mint a new id.
+ */ export class CredentialKeyID extends KubunID {
+    static create(owner, unique) {
+        return new CredentialKeyID(createDigest(owner, unique));
+    }
+    static fromBytes(input) {
+        return new CredentialKeyID(decodeDigest(input, CREDENTIAL_KEY));
+    }
+    static fromString(input) {
+        return CredentialKeyID.fromBytes(base36.decode(input));
+    }
+    static from(input) {
+        if (input instanceof CredentialKeyID) {
+            return input;
+        }
+        if (input instanceof Uint8Array) {
+            return CredentialKeyID.fromBytes(input);
+        }
+        if (typeof input === 'string') {
+            return CredentialKeyID.fromString(input);
+        }
+        throw new Error('Unsupported input type');
+    }
+    #digest;
+    constructor(digest){
+        super(CREDENTIAL_KEY, encodeData(digest));
+        this.#digest = digest;
+    }
+    get digest() {
+        return this.#digest;
+    }
+}
+/**
+ * A credential entry: one encrypted value under a key.
+ *
+ * Does not embed its key's id. An entry can be re-keyed without every document
+ * that references it changing, and its value changes — a refreshed OAuth token —
+ * without the reference changing either.
+ */ export class CredentialEntryID extends KubunID {
+    static create(owner, unique) {
+        return new CredentialEntryID(createDigest(owner, unique));
+    }
+    static fromBytes(input) {
+        return new CredentialEntryID(decodeDigest(input, CREDENTIAL_ENTRY));
+    }
+    static fromString(input) {
+        return CredentialEntryID.fromBytes(base36.decode(input));
+    }
+    static from(input) {
+        if (input instanceof CredentialEntryID) {
+            return input;
+        }
+        if (input instanceof Uint8Array) {
+            return CredentialEntryID.fromBytes(input);
+        }
+        if (typeof input === 'string') {
+            return CredentialEntryID.fromString(input);
+        }
+        throw new Error('Unsupported input type');
+    }
+    #digest;
+    constructor(digest){
+        super(CREDENTIAL_ENTRY, encodeData(digest));
+        this.#digest = digest;
+    }
+    get digest() {
+        return this.#digest;
+    }
+}

package/lib/decode.js

@@ -1,7 +1,8 @@
 import { base36 } from 'multiformats/bases/base36';
 import { AttachmentID } from './attachment.js';
-import { AttachmentType, DocumentType, ExternalType, ModelType, NAMESPACE_CODE } from './base.js';
+import { ATTACHMENT_BINARY, CREDENTIAL_ENTRY, CREDENTIAL_KEY, DOCUMENT_MERGE, EXTERNAL_PLUGIN_NODE, MODEL_CLUSTER, MODEL_DOCUMENT, MODEL_SCALAR, MODEL_SHAPE, NAMESPACE_CODE } from './base.js';
 import { ClusterModelID } from './cluster-model.js';
+import { CredentialEntryID, CredentialKeyID } from './credential.js';
 import { DocumentID } from './document.js';
 import { DocumentModelID, ScalarModelID, ShapeModelID } from './model.js';
 import { PluginNodeID } from './plugin-node.js';
@@ -14,19 +15,23 @@ export function decodeID(input) {
     }
     const [type] = decodeVarint(bytes, namespaceLength);
     switch(type){
-        case AttachmentType.BINARY:
+        case ATTACHMENT_BINARY:
             return AttachmentID.fromBytes(bytes);
-        case ModelType.SCALAR:
+        case MODEL_SCALAR:
             return ScalarModelID.fromBytes(bytes);
-        case ModelType.SHAPE:
+        case MODEL_SHAPE:
             return ShapeModelID.fromBytes(bytes);
-        case ModelType.DOCUMENT:
+        case MODEL_DOCUMENT:
             return DocumentModelID.fromBytes(bytes);
-        case ModelType.CLUSTER:
+        case MODEL_CLUSTER:
             return ClusterModelID.fromBytes(bytes);
-        case DocumentType.MERGE_DOCUMENT:
+        case DOCUMENT_MERGE:
             return DocumentID.fromBytes(bytes);
-        case ExternalType.PLUGIN_NODE:
+        case CREDENTIAL_KEY:
+            return CredentialKeyID.fromBytes(bytes);
+        case CREDENTIAL_ENTRY:
+            return CredentialEntryID.fromBytes(bytes);
+        case EXTERNAL_PLUGIN_NODE:
             return PluginNodeID.fromBytes(bytes);
         default:
             throw new Error(`Invalid KubunID: unknown type ${type}`);

package/lib/document.d.ts

@@ -1,6 +1,6 @@
-import { DocumentType, KubunID } from './base.js';
+import { DOCUMENT_MERGE, KubunID } from './base.js';
 import { DocumentModelID } from './model.js';
-export declare class DocumentID extends KubunID<DocumentType.MERGE_DOCUMENT> {
+export declare class DocumentID extends KubunID<typeof DOCUMENT_MERGE> {
     #private;
     static create(model: DocumentModelID | Uint8Array | string, owner: string | Uint8Array, unique: Uint8Array): DocumentID;
     static fromBytes(input: Uint8Array): DocumentID;

package/lib/document.js

@@ -1,6 +1,6 @@
 import { fromUTF } from '@sozai/codec';
 import { base36 } from 'multiformats/bases/base36';
-import { DocumentType, KubunID, NAMESPACE_CODE } from './base.js';
+import { DOCUMENT_MERGE, KubunID, NAMESPACE_CODE } from './base.js';
 import { concat } from './bytes.js';
 import { DocumentModelID } from './model.js';
 import { decodeVarint, digestBytes, encodeVarint } from './utils.js';
@@ -22,7 +22,7 @@ export class DocumentID extends KubunID {
         offset += namespaceLength;
         // Check type matches
         const [type, typeLength] = decodeVarint(input, offset);
-        if (type !== DocumentType.MERGE_DOCUMENT) {
+        if (type !== DOCUMENT_MERGE) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         offset += typeLength;
@@ -68,7 +68,7 @@ export class DocumentID extends KubunID {
             encodeVarint(contentDigestBytes.byteLength),
             contentDigestBytes
         ]);
-        super(DocumentType.MERGE_DOCUMENT, data);
+        super(DOCUMENT_MERGE, data);
         this.#model = model;
         this.#content = contentDigestBytes;
     }

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 export { AttachmentID } from './attachment.js';
 export { KubunID } from './base.js';
 export { ClusterModelID } from './cluster-model.js';
+export { CredentialEntryID, CredentialKeyID } from './credential.js';
 export { decodeID } from './decode.js';
 export { DocumentID } from './document.js';
 export { DocumentModelID, ScalarModelID, ShapeModelID } from './model.js';

package/lib/index.js

@@ -1,6 +1,7 @@
 export { AttachmentID } from './attachment.js';
 export { KubunID } from './base.js';
 export { ClusterModelID } from './cluster-model.js';
+export { CredentialEntryID, CredentialKeyID } from './credential.js';
 export { decodeID } from './decode.js';
 export { DocumentID } from './document.js';
 export { DocumentModelID, ScalarModelID, ShapeModelID } from './model.js';

package/lib/model.d.ts

@@ -1,17 +1,17 @@
-import { KubunID, ModelType } from './base.js';
-export declare class ScalarModelID extends KubunID<ModelType.SCALAR> {
+import { KubunID, MODEL_DOCUMENT, MODEL_SCALAR, MODEL_SHAPE } from './base.js';
+export declare class ScalarModelID extends KubunID<typeof MODEL_SCALAR> {
     static create(value: unknown): ScalarModelID;
     static fromBytes(input: Uint8Array): ScalarModelID;
     static fromString(input: string): ScalarModelID;
     constructor(digestBytes: Uint8Array);
 }
-export declare class ShapeModelID extends KubunID<ModelType.SHAPE> {
+export declare class ShapeModelID extends KubunID<typeof MODEL_SHAPE> {
     static create(value: unknown): ShapeModelID;
     static fromBytes(input: Uint8Array): ShapeModelID;
     static fromString(input: string): ShapeModelID;
     constructor(digestBytes: Uint8Array);
 }
-export declare class DocumentModelID extends KubunID<ModelType.DOCUMENT> {
+export declare class DocumentModelID extends KubunID<typeof MODEL_DOCUMENT> {
     #private;
     static fromBytes(input: Uint8Array): DocumentModelID;
     static fromString(input: string): DocumentModelID;

package/lib/model.js

@@ -1,5 +1,5 @@
 import { base36 } from 'multiformats/bases/base36';
-import { KubunID, ModelType, NAMESPACE_CODE } from './base.js';
+import { KubunID, MODEL_DOCUMENT, MODEL_SCALAR, MODEL_SHAPE, NAMESPACE_CODE } from './base.js';
 import { concat } from './bytes.js';
 import { decodeVarint, digestJSON, encodeVarint } from './utils.js';
 export class ScalarModelID extends KubunID {
@@ -12,7 +12,7 @@ export class ScalarModelID extends KubunID {
             throw new Error('Invalid KubunID: namespace mismatch');
         }
         const [type, typeLength] = decodeVarint(input, namespaceLength);
-        if (type !== ModelType.SCALAR) {
+        if (type !== MODEL_SCALAR) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         const digestBytes = input.slice(namespaceLength + typeLength);
@@ -22,7 +22,7 @@ export class ScalarModelID extends KubunID {
         return ScalarModelID.fromBytes(base36.decode(input));
     }
     constructor(digestBytes){
-        super(ModelType.SCALAR, digestBytes);
+        super(MODEL_SCALAR, digestBytes);
     }
 }
 export class ShapeModelID extends KubunID {
@@ -35,7 +35,7 @@ export class ShapeModelID extends KubunID {
             throw new Error('Invalid KubunID: namespace mismatch');
         }
         const [type, typeLength] = decodeVarint(input, namespaceLength);
-        if (type !== ModelType.SHAPE) {
+        if (type !== MODEL_SHAPE) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         const digestBytes = input.slice(namespaceLength + typeLength);
@@ -45,7 +45,7 @@ export class ShapeModelID extends KubunID {
         return ShapeModelID.fromBytes(base36.decode(input));
     }
     constructor(digestBytes){
-        super(ModelType.SHAPE, digestBytes);
+        super(MODEL_SHAPE, digestBytes);
     }
 }
 const MAX_INDEX = 127;
@@ -56,7 +56,7 @@ export class DocumentModelID extends KubunID {
             throw new Error('Invalid KubunID: namespace mismatch');
         }
         const [type, typeLength] = decodeVarint(input, namespaceLength);
-        if (type !== ModelType.DOCUMENT) {
+        if (type !== MODEL_DOCUMENT) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         const digestBytes = input.slice(namespaceLength + typeLength, input.byteLength - 1);
@@ -88,7 +88,7 @@ export class DocumentModelID extends KubunID {
             // index should be encoded in a single byte
             throw new RangeError(`Index ${index} exceeds maximum of ${MAX_INDEX}`);
         }
-        super(ModelType.DOCUMENT, digestBytes);
+        super(MODEL_DOCUMENT, digestBytes);
         this.#index = index;
         this.#isLocal = digestBytes.length === 0;
     }

package/lib/plugin-node.d.ts

@@ -1,5 +1,5 @@
-import { ExternalType, KubunID } from './base.js';
-export declare class PluginNodeID extends KubunID<ExternalType.PLUGIN_NODE> {
+import { EXTERNAL_PLUGIN_NODE, KubunID } from './base.js';
+export declare class PluginNodeID extends KubunID<typeof EXTERNAL_PLUGIN_NODE> {
     #private;
     static create(plugin: string, typeName: string, localID: string): PluginNodeID;
     static fromBytes(input: Uint8Array): PluginNodeID;

package/lib/plugin-node.js

@@ -1,6 +1,6 @@
 import { fromUTF, toUTF } from '@sozai/codec';
 import { base36 } from 'multiformats/bases/base36';
-import { ExternalType, KubunID, NAMESPACE_CODE } from './base.js';
+import { EXTERNAL_PLUGIN_NODE, KubunID, NAMESPACE_CODE } from './base.js';
 import { concat } from './bytes.js';
 import { decodeVarint, encodeVarint } from './utils.js';
 export class PluginNodeID extends KubunID {
@@ -17,7 +17,7 @@ export class PluginNodeID extends KubunID {
         offset += namespaceLength;
         // Check type matches
         const [type, typeLength] = decodeVarint(input, offset);
-        if (type !== ExternalType.PLUGIN_NODE) {
+        if (type !== EXTERNAL_PLUGIN_NODE) {
             throw new Error('Invalid KubunID: type mismatch');
         }
         offset += typeLength;
@@ -67,7 +67,7 @@ export class PluginNodeID extends KubunID {
             encodeVarint(localIDBytes.byteLength),
             localIDBytes
         ]);
-        super(ExternalType.PLUGIN_NODE, data);
+        super(EXTERNAL_PLUGIN_NODE, data);
         this.#plugin = plugin;
         this.#typeName = typeName;
         this.#localID = localID;

package/package.json

@@ -1,36 +1,39 @@
 {
   "name": "@kubun/id",
-  "version": "0.11.0",
-  "license": "see LICENSE.md",
+  "version": "0.13.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@sozai/codec": "^0.1.0",
-    "@noble/hashes": "^2.2.0",
-    "multiformats": "^14.0.4",
+    "@noble/hashes": "^2.3.0",
+    "@sozai/codec": "^0.4.0",
+    "multiformats": "^14.0.5",
     "varint": "^6.0.0"
   },
   "devDependencies": {
     "@types/varint": "^6.0.3"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "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:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }