@openlfcp/shared-objects 0.3.1 → 0.5.0

package/README.md

@@ -40,7 +40,7 @@ without notice until the profile is in a baseline.
 ## Identity profile (MVP 0.4 Working Draft)
 
 `@openlfcp/shared-objects/identity` implements IDENTITY-PROFILE-01 §§2–4
-(`org.openlfcp.identity.v1`, `mvp-0.4-baseline.2`, LFCP-04-409 and 409b).
+(`org.openlfcp.identity.v1`, `mvp-0.4-baseline.4`, LFCP-04-409 and 409b).
 `IdentityReplica` admits changes with AI0–AI5, validates every concurrent
 field value and exposes `roster()`, `devices()` and `requests()`. Invalid
 entries are omitted; an invalid root makes all three readers empty.

package/dist/data-profile.d.ts

@@ -184,4 +184,24 @@ export declare class SharedObjectsDataProfile {
      */
     exclude(unitIds: readonly DataUnitId[]): SharedObjectsExcludeResult;
 }
+/**
+ * The codec of one unit of this profile, bound to its Resource and signer
+ * (§8, §11, SO-SEC1): a unit carries only changes of its signer's §8 actor,
+ * so no Principal can write into another Principal's Automerge history.
+ * Anything else is PROFILE_INVALID / CHANGE_ACTOR_MISMATCH. The same check
+ * whether a receiver merges the unit or a rotation judges it.
+ */
+export declare function sharedObjectsCodecFor(unit: {
+    readonly resourceId: ResourceId;
+    readonly actor: PrincipalId;
+}): SharedObjectsCodec;
+/**
+ * This profile's per-unit check without a replica (structurally the client's
+ * UnitProfile): for the identity flows' rotation frontier
+ * (FlowOptions.profiles), which judges units as recipients do.
+ */
+export declare const sharedObjectsUnitProfile: Readonly<{
+    dataProfile: "org.openlfcp.shared-objects.v1";
+    codecFor: typeof sharedObjectsCodecFor;
+}>;
 //# sourceMappingURL=data-profile.d.ts.map

package/dist/data-profile.js

@@ -155,16 +155,7 @@ export class SharedObjectsDataProfile {
         return [...this.#pending.values()].map((b) => b.unitId);
     }
     codecFor(unit) {
-        const actor = toHex(deriveActorId(unit.resourceId, unit.actor));
-        // §8, §11 (SO-SEC1): a unit carries only changes of its signer's §8
-        // actor, so no Principal can write into another Principal's Automerge
-        // history. Anything else is PROFILE_INVALID / CHANGE_ACTOR_MISMATCH.
-        const bound = (change) => checkChangeActor(change, actor);
-        return {
-            dataProfile: PROFILE_ID,
-            encode: (change) => frameChange(bound(change).bytes),
-            decode: (plaintext) => bound(unframeChange(plaintext)),
-        };
+        return sharedObjectsCodecFor(unit);
     }
     apply(unit, change) {
         const key = toHex(unit.unitId);
@@ -362,4 +353,29 @@ function rebuildChanges(before, after) {
     }
     return out;
 }
+/**
+ * The codec of one unit of this profile, bound to its Resource and signer
+ * (§8, §11, SO-SEC1): a unit carries only changes of its signer's §8 actor,
+ * so no Principal can write into another Principal's Automerge history.
+ * Anything else is PROFILE_INVALID / CHANGE_ACTOR_MISMATCH. The same check
+ * whether a receiver merges the unit or a rotation judges it.
+ */
+export function sharedObjectsCodecFor(unit) {
+    const actor = toHex(deriveActorId(unit.resourceId, unit.actor));
+    const bound = (change) => checkChangeActor(change, actor);
+    return {
+        dataProfile: PROFILE_ID,
+        encode: (change) => frameChange(bound(change).bytes),
+        decode: (plaintext) => bound(unframeChange(plaintext)),
+    };
+}
+/**
+ * This profile's per-unit check without a replica (structurally the client's
+ * UnitProfile): for the identity flows' rotation frontier
+ * (FlowOptions.profiles), which judges units as recipients do.
+ */
+export const sharedObjectsUnitProfile = Object.freeze({
+    dataProfile: PROFILE_ID,
+    codecFor: sharedObjectsCodecFor,
+});
 //# sourceMappingURL=data-profile.js.map

package/dist/identity/index.d.ts

@@ -1,6 +1,6 @@
 /** IDENTITY-PROFILE-01 §§2–4. No authority is inferred from document metadata. */
 export { checkIdentityUnit, IDENTITY_ADMISSION_ORDER, IdentityAdmission, type IdentityAdmissionDiagnostic, IdentityAdmissionError, } from "./admission.js";
-export { type IdentityIntent, type IdentityOptions, type IdentityReceiveResult, type IdentityRefusal, IdentityReplica, type IdentityUnit, identityCodec, identitySnapshotCodec, } from "./replica.js";
+export { type IdentityIntent, type IdentityOptions, type IdentityReceiveResult, type IdentityRefusal, IdentityReplica, type IdentityUnit, type IdentityWriteOptions, identityCodec, identityCodecFor, identitySnapshotCodec, identityUnitProfile, } from "./replica.js";
 export { IDENTITY_DIAGNOSTIC_ORDER, type IdentityDiagnostic, type IdentityProblem, type IdentityValidation, validateIdentity, } from "./schema.js";
 export { type DeviceEntry, deriveIdentityActorId, IDENTITY_PROFILE_ID, type IdentityDocument, type IdentityEpoch, type IdentityWriter, type IdentityWriterClass, isResourceRef, type PairingRequest, type ResourceRef, type RosterEntry, } from "./values.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/identity/index.js

@@ -1,6 +1,6 @@
 /** IDENTITY-PROFILE-01 §§2–4. No authority is inferred from document metadata. */
 export { checkIdentityUnit, IDENTITY_ADMISSION_ORDER, IdentityAdmission, IdentityAdmissionError, } from "./admission.js";
-export { IdentityReplica, identityCodec, identitySnapshotCodec, } from "./replica.js";
+export { IdentityReplica, identityCodec, identityCodecFor, identitySnapshotCodec, identityUnitProfile, } from "./replica.js";
 export { IDENTITY_DIAGNOSTIC_ORDER, validateIdentity, } from "./schema.js";
 export { deriveIdentityActorId, IDENTITY_PROFILE_ID, isResourceRef, } from "./values.js";
 //# sourceMappingURL=index.js.map

package/dist/identity/replica.d.ts

@@ -25,6 +25,15 @@ export interface IdentityReceiveResult {
     readonly waiting: readonly string[];
     readonly refused: readonly IdentityRefusal[];
 }
+/** Options of IdentityReplica.write. */
+export interface IdentityWriteOptions {
+    /**
+     * Device entries (PrincipalRefs) whose `revoked` flag the change sets to
+     * `true` after the intents, writing no other field of them: a retired
+     * entry (IDENTITY-PROFILE-01 §7.1 step 4, §8.2). Each entry must exist.
+     */
+    readonly retire?: readonly string[];
+}
 export type IdentityIntent = {
     readonly intent: "identity.initialize";
 } | {
@@ -91,19 +100,53 @@ export declare class IdentityReplica {
         readonly hash: string;
         readonly signer: PrincipalId;
     }[];
+    /**
+     * Every value the scalar field `table[key].field` holds now: one, or
+     * several under concurrent writes (identical values once, SOP §45); none
+     * when the field is absent or `table[key]` is not one map. Strings, uints
+     * and booleans as JavaScript values. `devices()` shows one of them; this
+     * is what IDENTITY-PROFILE-01 §7.1 step 4 reads of a retired entry's
+     * `revoked` ("some value is not true").
+     */
+    fieldValues(table: "roster" | "devices" | "requests", key: string, field: string): readonly unknown[];
     /**
      * One transaction (one change) for the intent, or for several intents in
      * order, e.g. the fill change of IDENTITY-PROFILE-01 §5.1 or the devices
      * entry and the request deletion of §5.3 step 6; scalar strings/uints,
-     * unknown fields preserved on updates.
+     * unknown fields preserved on updates. `options.retire` adds the
+     * `revoked = true` flag of retired entries, field by field.
      */
-    write(writer: IdentityWriter, intent: IdentityIntent | readonly IdentityIntent[]): CheckedChange;
+    write(writer: IdentityWriter, intent: IdentityIntent | readonly IdentityIntent[], options?: IdentityWriteOptions): CheckedChange;
 }
 export declare const identityCodec: Readonly<{
     dataProfile: "org.openlfcp.identity.v1";
     encode: (change: CheckedChange) => Uint8Array;
     decode: typeof unframeChange;
 }>;
+/**
+ * The codec of one unit of the Identity Profile, bound to its Resource and
+ * signer (§3: a change in another actor's sequence is CHANGE_ACTOR_MISMATCH).
+ * The writer-class rules (AI0–AI4) need the Control state at the unit's
+ * control_ref and stay with the document's admission (IdentityReplica.receive).
+ */
+export declare function identityCodecFor(unit: {
+    readonly resourceId: ResourceId;
+    readonly actor: PrincipalId;
+}): Readonly<{
+    dataProfile: "org.openlfcp.identity.v1";
+    encode: (change: CheckedChange) => Uint8Array;
+    decode: (plaintext: Uint8Array) => CheckedChange;
+}>;
+/**
+ * The Identity Profile's per-unit check without a replica (structurally the
+ * client's UnitProfile): for the identity flows' rotation frontier
+ * (FlowOptions.profiles), so a rotation of the Identity Resource judges its
+ * units as recipients do.
+ */
+export declare const identityUnitProfile: Readonly<{
+    dataProfile: "org.openlfcp.identity.v1";
+    codecFor: typeof identityCodecFor;
+}>;
 export declare const identitySnapshotCodec: Readonly<{
     dataProfile: "org.openlfcp.identity.v1";
     encode: typeof frameSnapshot;

package/dist/identity/replica.js

@@ -1,5 +1,6 @@
 import * as A from "@automerge/automerge";
 import { bytesEqual, dataEpoch, LfcpError, toHex, } from "@openlfcp/core";
+import { checkChangeActor } from "../admission/actor.js";
 import { checkChange, checkSaveHeader, frameChange, frameSnapshot, parsedOf, refusedChangeHash, unframeChange, unframeSnapshot, } from "../admission/framing.js";
 import { checkSnapshotExpansion, SNAPSHOT_LIMITS_FLOOR, } from "../admission/limits.js";
 import { ReferenceHistory } from "../admission/references.js";
@@ -7,6 +8,7 @@ import { admitBatch, admitChange } from "../admission/sequence.js";
 import { isWasmTrap } from "../replica.js";
 import { principalRef } from "../values.js";
 import { checkIdentityUnit, IdentityAdmission, refuseIdentity } from "./admission.js";
+import { IdentityReader } from "./reader.js";
 import { validateIdentity } from "./schema.js";
 import { deriveIdentityActorId, IDENTITY_PROFILE_ID, } from "./values.js";
 const refusal = (hash, error, held = false) => ({
@@ -244,17 +246,35 @@ export class IdentityReplica {
         }
         return Object.freeze(out);
     }
+    /**
+     * Every value the scalar field `table[key].field` holds now: one, or
+     * several under concurrent writes (identical values once, SOP §45); none
+     * when the field is absent or `table[key]` is not one map. Strings, uints
+     * and booleans as JavaScript values. `devices()` shows one of them; this
+     * is what IDENTITY-PROFILE-01 §7.1 step 4 reads of a retired entry's
+     * `revoked` ("some value is not true").
+     */
+    fieldValues(table, key, field) {
+        const reader = new IdentityReader(this.#doc);
+        const container = reader.map("_root", table);
+        const entry = container === undefined ? undefined : reader.map(container, key);
+        if (entry === undefined)
+            return Object.freeze([]);
+        return Object.freeze(reader.all(entry, field).map(([, value]) => value));
+    }
     /**
      * One transaction (one change) for the intent, or for several intents in
      * order, e.g. the fill change of IDENTITY-PROFILE-01 §5.1 or the devices
      * entry and the request deletion of §5.3 step 6; scalar strings/uints,
-     * unknown fields preserved on updates.
+     * unknown fields preserved on updates. `options.retire` adds the
+     * `revoked = true` flag of retired entries, field by field.
      */
-    write(writer, intent) {
+    write(writer, intent, options = {}) {
         const intents = Array.isArray(intent)
             ? intent
             : [intent];
-        if (intents.length === 0)
+        const retire = options.retire ?? [];
+        if (intents.length === 0 && retire.length === 0)
             throw new LfcpError("PROFILE_INVALID", "no intent to write");
         // AI5 (§3) refuses the change anyway; say why before building it.
         for (const i of intents)
@@ -269,14 +289,19 @@ export class IdentityReplica {
             const doc = A.change(fork, { time: 0 }, (d) => {
                 for (const i of intents)
                     applyIntent(d, i, this.#options.root, A.getBackend(d));
+                for (const key of retire)
+                    retireEntry(d, key);
             });
             const last = A.getLastLocalChange(doc);
             if (last === null || last === undefined)
                 throw new LfcpError("PROFILE_INVALID", "the intent did not create a change");
             bytes = last;
             const validation = validateIdentity(doc, this.#options.root);
-            for (const i of intents) {
-                const base = "key" in i ? `/${tableOf(i)}/${i.key}` : "";
+            const written = [
+                ...intents.map((i) => ("key" in i ? `/${tableOf(i)}/${i.key}` : "")),
+                ...retire.map((key) => `/devices/${key}`),
+            ];
+            for (const base of written) {
                 const problem = validation.problems.find((p) => p.diagnostic === "INVALID_ROOT" ||
                     p.pointer === base ||
                     p.pointer.startsWith(`${base}/`));
@@ -342,6 +367,16 @@ function applyIntent(d, intent, root, backend) {
         if (value !== undefined)
             putValue(entry, key, value, backend);
 }
+/** `devices[key].revoked = true`, and nothing else of the entry (§7.1 step 4, §8.2). */
+function retireEntry(d, key) {
+    const devices = d.devices;
+    if (devices === undefined)
+        refuseIdentity("INVALID_ROOT", "initialize the identity first");
+    const entry = Object.hasOwn(devices, key) ? devices[key] : undefined;
+    if (entry === null || typeof entry !== "object")
+        throw new LfcpError("PROFILE_INVALID", `no device entry ${key} to retire`);
+    entry.revoked = true;
+}
 function putValue(target, key, value, backend) {
     const map = target;
     if (typeof value === "string")
@@ -376,6 +411,31 @@ export const identityCodec = Object.freeze({
     encode: (change) => frameChange(change.bytes),
     decode: unframeChange,
 });
+/**
+ * The codec of one unit of the Identity Profile, bound to its Resource and
+ * signer (§3: a change in another actor's sequence is CHANGE_ACTOR_MISMATCH).
+ * The writer-class rules (AI0–AI4) need the Control state at the unit's
+ * control_ref and stay with the document's admission (IdentityReplica.receive).
+ */
+export function identityCodecFor(unit) {
+    const actor = toHex(deriveIdentityActorId(unit.resourceId, unit.actor));
+    const bound = (change) => checkChangeActor(change, actor);
+    return Object.freeze({
+        dataProfile: IDENTITY_PROFILE_ID,
+        encode: (change) => frameChange(bound(change).bytes),
+        decode: (plaintext) => bound(unframeChange(plaintext)),
+    });
+}
+/**
+ * The Identity Profile's per-unit check without a replica (structurally the
+ * client's UnitProfile): for the identity flows' rotation frontier
+ * (FlowOptions.profiles), so a rotation of the Identity Resource judges its
+ * units as recipients do.
+ */
+export const identityUnitProfile = Object.freeze({
+    dataProfile: IDENTITY_PROFILE_ID,
+    codecFor: identityCodecFor,
+});
 export const identitySnapshotCodec = Object.freeze({
     dataProfile: IDENTITY_PROFILE_ID,
     encode: frameSnapshot,

package/dist/index.d.ts

@@ -6,7 +6,7 @@
 export declare const PACKAGE = "@openlfcp/shared-objects";
 export { type CheckedChange, checkChange, checkSaveHeader, frameChange, frameSnapshot, unframeChange, unframeSnapshot, } from "./admission/framing.js";
 export { CHANGE_LIMITS, type ChunkExpansion, checkChangeExpansion, checkSnapshotExpansion, MAX_DOCUMENT_DEPTH, SNAPSHOT_LIMITS_FLOOR, type SnapshotLimits, } from "./admission/limits.js";
-export { type SharedObjectsApplyResult, type SharedObjectsBatchResult, type SharedObjectsCheckpoint, type SharedObjectsCodec, SharedObjectsDataProfile, type SharedObjectsDiagnostic, type SharedObjectsExcludeResult, type SharedObjectsListenerFailure, type SharedObjectsSnapshotCodec, type SharedObjectsUnit, } from "./data-profile.js";
+export { type SharedObjectsApplyResult, type SharedObjectsBatchResult, type SharedObjectsCheckpoint, type SharedObjectsCodec, SharedObjectsDataProfile, type SharedObjectsDiagnostic, type SharedObjectsExcludeResult, type SharedObjectsListenerFailure, type SharedObjectsSnapshotCodec, type SharedObjectsUnit, sharedObjectsCodecFor, sharedObjectsUnitProfile, } from "./data-profile.js";
 export { applyBatchChecked, applyChecked, type BatchReceiveResult, type BuiltReplica, isWasmTrap, type LocalChange, type ObjectChange, ObjectIdCollisionError, type ObjectStatus, type ReceiveResult, type ReplicaIntent, type ReplicaOptions, type ReplicaValidation, type ResolveFieldConflict, resolveFieldConflict, SCALAR_FIELDS, type ScalarField, type ScalarView, SharedObjectsReplica, type TaskView, } from "./replica.js";
 export { addTag, assign, cancel, clearDue, clearScheduled, complete, createTask, deleteTask, type NewTask, type ParsedTask, ProfileError, parseTask, removeTag, reopen, restoreTask, setDue, setPriority, setScheduled, setStatus, setTitle, type Task, type TaskChange, type TaskIntent, type TaskPriority, type TaskStatus, taskToJson, unassign, } from "./task.js";
 export { DIAGNOSTIC_ORDER, firstPerField, isMap, type Json, objectProblems, type ProfileDiagnostic, ProfileInvalidError, type ProfileProblem, pointerToken, type RootValidation, validateRoot, validateTransition, } from "./validate.js";

package/dist/index.js

@@ -6,7 +6,7 @@
 export const PACKAGE = "@openlfcp/shared-objects";
 export { checkChange, checkSaveHeader, frameChange, frameSnapshot, unframeChange, unframeSnapshot, } from "./admission/framing.js";
 export { CHANGE_LIMITS, checkChangeExpansion, checkSnapshotExpansion, MAX_DOCUMENT_DEPTH, SNAPSHOT_LIMITS_FLOOR, } from "./admission/limits.js";
-export { SharedObjectsDataProfile, } from "./data-profile.js";
+export { SharedObjectsDataProfile, sharedObjectsCodecFor, sharedObjectsUnitProfile, } from "./data-profile.js";
 export { applyBatchChecked, applyChecked, isWasmTrap, ObjectIdCollisionError, resolveFieldConflict, SCALAR_FIELDS, SharedObjectsReplica, } from "./replica.js";
 export { addTag, assign, cancel, clearDue, clearScheduled, complete, createTask, deleteTask, ProfileError, parseTask, removeTag, reopen, restoreTask, setDue, setPriority, setScheduled, setStatus, setTitle, taskToJson, unassign, } from "./task.js";
 export { DIAGNOSTIC_ORDER, firstPerField, isMap, objectProblems, ProfileInvalidError, pointerToken, validateRoot, validateTransition, } from "./validate.js";

package/dist/sections/data-profile.d.ts

@@ -209,4 +209,21 @@ export declare class SharedSectionsDataProfile {
         readonly principal: PrincipalId;
     }): SharedSectionsDataProfile;
 }
+/**
+ * The codec of one unit of this profile, bound to its signer's section actor
+ * (§2): a change of another actor is PROFILE_INVALID / CHANGE_ACTOR_MISMATCH.
+ * The same check whether a receiver merges the unit or a rotation judges it.
+ */
+export declare function sectionsCodecFor(unit: {
+    readonly resourceId: ResourceId;
+    readonly actor: PrincipalId;
+}): SectionsCodec;
+/**
+ * This profile's per-unit check without a replica (structurally the client's
+ * UnitProfile): for the identity flows' rotation frontier (FlowOptions.profiles).
+ */
+export declare const sectionsUnitProfile: Readonly<{
+    dataProfile: "org.openlfcp.shared-sections.v1";
+    codecFor: typeof sectionsCodecFor;
+}>;
 //# sourceMappingURL=data-profile.d.ts.map

package/dist/sections/data-profile.js

@@ -105,13 +105,7 @@ export class SharedSectionsDataProfile {
     }
     /** The codec of one unit, bound to its signer's section actor (§2). */
     codecFor(unit) {
-        const actor = toHex(deriveSectionActorId(unit.resourceId, unit.actor));
-        const bound = (c) => checkChangeActor(c, actor);
-        return {
-            dataProfile: SECTIONS_PROFILE_ID,
-            encode: (change) => frameChange(bound(change).bytes),
-            decode: (plaintext) => bound(unframeChange(plaintext)),
-        };
+        return sectionsCodecFor(unit);
     }
     /**
      * SDK-SECTIONS-INTEGRATION-01 §3.1: the binding through which a sync
@@ -401,4 +395,26 @@ export class SharedSectionsDataProfile {
         return profile;
     }
 }
+/**
+ * The codec of one unit of this profile, bound to its signer's section actor
+ * (§2): a change of another actor is PROFILE_INVALID / CHANGE_ACTOR_MISMATCH.
+ * The same check whether a receiver merges the unit or a rotation judges it.
+ */
+export function sectionsCodecFor(unit) {
+    const actor = toHex(deriveSectionActorId(unit.resourceId, unit.actor));
+    const bound = (c) => checkChangeActor(c, actor);
+    return {
+        dataProfile: SECTIONS_PROFILE_ID,
+        encode: (change) => frameChange(bound(change).bytes),
+        decode: (plaintext) => bound(unframeChange(plaintext)),
+    };
+}
+/**
+ * This profile's per-unit check without a replica (structurally the client's
+ * UnitProfile): for the identity flows' rotation frontier (FlowOptions.profiles).
+ */
+export const sectionsUnitProfile = Object.freeze({
+    dataProfile: SECTIONS_PROFILE_ID,
+    codecFor: sectionsCodecFor,
+});
 //# sourceMappingURL=data-profile.js.map

package/dist/sections/index.d.ts

@@ -8,7 +8,7 @@
  * shared `@openlfcp/shared-objects/admission` with SECTIONS_ACTOR_DOMAIN.
  */
 export { ADMISSION_ORDER, type AdmissionDiagnostic, SectionAdmissionError, } from "./admission.js";
-export { type SectionsApplyResult, type SectionsBatchResult, type SectionsCheckpoint, type SectionsCodec, type SectionsCommitBinding, type SectionsExcludeResult, type SectionsListenerFailure, type SectionsNodesChanged, type SectionsSnapshotBinding, type SectionsSnapshotCodec, type SectionsStagedOperation, type SectionsUnit, SharedSectionsDataProfile, } from "./data-profile.js";
+export { type SectionsApplyResult, type SectionsBatchResult, type SectionsCheckpoint, type SectionsCodec, type SectionsCommitBinding, type SectionsExcludeResult, type SectionsListenerFailure, type SectionsNodesChanged, type SectionsSnapshotBinding, type SectionsSnapshotCodec, type SectionsStagedOperation, type SectionsUnit, SharedSectionsDataProfile, sectionsCodecFor, sectionsUnitProfile, } from "./data-profile.js";
 export { type ProfileModel, profileModel, SUPPORTED_DATA_PROFILES, taskRefModel, } from "./dispatch.js";
 export { SectionDocument, type ValueType } from "./document.js";
 export { AUTHORING_BUDGET, type SectionIntent, type SectionIntentCode, SectionIntentError, type SectionLocalChange, type SectionReceiveResult, type SectionRefusal, SectionReplica, type SectionReplicaOptions, type SectionSnapshot, type SectionSnapshotNode, type SectionUnit, type StagedSectionChange, type TextEdit, } from "./replica.js";

package/dist/sections/index.js

@@ -8,7 +8,7 @@
  * shared `@openlfcp/shared-objects/admission` with SECTIONS_ACTOR_DOMAIN.
  */
 export { ADMISSION_ORDER, SectionAdmissionError, } from "./admission.js";
-export { SharedSectionsDataProfile, } from "./data-profile.js";
+export { SharedSectionsDataProfile, sectionsCodecFor, sectionsUnitProfile, } from "./data-profile.js";
 export { profileModel, SUPPORTED_DATA_PROFILES, taskRefModel, } from "./dispatch.js";
 export { SectionDocument } from "./document.js";
 export { AUTHORING_BUDGET, SectionIntentError, SectionReplica, } from "./replica.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/shared-objects",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "SHARED-OBJECTS-PROFILE-01 (org.openlfcp.shared-objects.v1) implementation.",
   "keywords": [
     "openlfcp",
@@ -57,8 +57,8 @@
   "dependencies": {
     "@automerge/automerge": "3.5.0",
     "fflate": "0.8.3",
-    "@openlfcp/core": "^0.3.1",
-    "@openlfcp/crypto": "^0.3.1"
+    "@openlfcp/core": "^0.5.0",
+    "@openlfcp/crypto": "^0.5.0"
   },
   "devDependencies": {
     "fast-check": "4.10.2"