@degenerate/generic 0.4.0 → 0.7.0

package/dist/errors/library/library-errors.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryEntityInvalidError = exports.LibraryVersionNotFoundError = exports.LibraryEntityNotFoundError = exports.LibraryKindMismatchError = exports.LibraryStoreConflictError = exports.LibraryVersionNotAuthorizedError = exports.LibraryDelegationNotAuthorizedError = exports.LibraryProofInvalidError = exports.LibraryChainBrokenError = exports.LibraryVersionHashMismatchError = void 0;
+const base_error_1 = require("../base-error");
+/**
+ * Thrown when a library version's recorded `currentHash` does not match the
+ * hash recomputed from its `source` + `previousHash`. The content of the
+ * version has been altered (or the hash was forged).
+ */
+class LibraryVersionHashMismatchError extends base_error_1.BaseError {
+    constructor(entityId, claimedHash, recomputedHash) {
+        super(`Library ${entityId}: version hash mismatch — recorded ${claimedHash}, recomputed ${recomputedHash}.`);
+        this.entityId = entityId;
+        this.claimedHash = claimedHash;
+        this.recomputedHash = recomputedHash;
+    }
+}
+exports.LibraryVersionHashMismatchError = LibraryVersionHashMismatchError;
+/**
+ * Thrown when a version's `previousHash` does not equal the `currentHash` of
+ * the version before it (the prior version's hash, or the empty seed for the
+ * first version). The append-only chain has been broken or reordered.
+ */
+class LibraryChainBrokenError extends base_error_1.BaseError {
+    constructor(entityId, expectedPreviousHash, actualPreviousHash) {
+        super(`Library ${entityId}: broken version chain — expected previousHash ${expectedPreviousHash || '<seed>'}, got ${actualPreviousHash || '<seed>'}.`);
+        this.entityId = entityId;
+        this.expectedPreviousHash = expectedPreviousHash;
+        this.actualPreviousHash = actualPreviousHash;
+    }
+}
+exports.LibraryChainBrokenError = LibraryChainBrokenError;
+/**
+ * Thrown when a version or head proof's Ed25519 signature does not verify
+ * against the canonical, purpose-bound payload reconstructed from the record.
+ * A signature was forged, or a signed field (including metadata such as
+ * `createdAt`, which is bound by the signature though not by the content hash)
+ * was tampered with.
+ */
+class LibraryProofInvalidError extends base_error_1.BaseError {
+    constructor(entityId, proofKind) {
+        super(`Library ${entityId}: ${proofKind} proof signature did not verify.`);
+        this.entityId = entityId;
+        this.proofKind = proofKind;
+    }
+}
+exports.LibraryProofInvalidError = LibraryProofInvalidError;
+/**
+ * Thrown when a delegation is registered by a key that is not the entity owner.
+ * Only the owner (the key that signed the first version) may delegate, which
+ * also blocks transitive delegation — a delegate's key is never the owner key,
+ * so a delegate can never register further delegates.
+ */
+class LibraryDelegationNotAuthorizedError extends base_error_1.BaseError {
+    constructor(entityId, attemptedBy, reason) {
+        super(`Library ${entityId}: delegation not authorized${reason ? ` (${reason})` : ''} — attempted by ${attemptedBy}.`);
+        this.entityId = entityId;
+        this.attemptedBy = attemptedBy;
+    }
+}
+exports.LibraryDelegationNotAuthorizedError = LibraryDelegationNotAuthorizedError;
+/**
+ * Thrown when a version's signer is neither the entity owner nor a verified
+ * delegate. Signature validity alone only proves *someone* signed the version;
+ * this proves the *authorized* someone did.
+ */
+class LibraryVersionNotAuthorizedError extends base_error_1.BaseError {
+    constructor(entityId, signerPublicKey) {
+        super(`Library ${entityId}: version signer ${signerPublicKey} is not the owner or an authorized delegate.`);
+        this.entityId = entityId;
+        this.signerPublicKey = signerPublicKey;
+    }
+}
+exports.LibraryVersionNotAuthorizedError = LibraryVersionNotAuthorizedError;
+/**
+ * Thrown when a store `save` would violate the append-only ledger: the incoming
+ * entity truncates or diverges from the stored history rather than extending it.
+ * The ledger may only grow, and existing versions may never change.
+ */
+class LibraryStoreConflictError extends base_error_1.BaseError {
+    constructor(entityId, reason) {
+        super(`Library ${entityId}: store conflict — ${reason}.`);
+        this.entityId = entityId;
+        this.reason = reason;
+    }
+}
+exports.LibraryStoreConflictError = LibraryStoreConflictError;
+/**
+ * Thrown when an entity is evaluated as the wrong kind — e.g. evaluating a rule
+ * entity through the function path. The entity is valid; the call is not.
+ */
+class LibraryKindMismatchError extends base_error_1.BaseError {
+    constructor(entityId, expected, actual) {
+        super(`Library ${entityId}: expected a ${expected} entity, got a ${actual}.`);
+        this.entityId = entityId;
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+exports.LibraryKindMismatchError = LibraryKindMismatchError;
+/** Thrown when a reference resolves to an id the store does not hold. */
+class LibraryEntityNotFoundError extends base_error_1.BaseError {
+    constructor(entityId) {
+        super(`Library ${entityId}: entity not found in store.`);
+        this.entityId = entityId;
+    }
+}
+exports.LibraryEntityNotFoundError = LibraryEntityNotFoundError;
+/**
+ * Thrown when a reference pins a `currentHash` that is not present in the
+ * entity's version ledger (e.g. a stale or forged reference).
+ */
+class LibraryVersionNotFoundError extends base_error_1.BaseError {
+    constructor(entityId, currentHash) {
+        super(`Library ${entityId}: no version ${currentHash} in the ledger.`);
+        this.entityId = entityId;
+        this.currentHash = currentHash;
+    }
+}
+exports.LibraryVersionNotFoundError = LibraryVersionNotFoundError;
+/**
+ * Thrown when a library entity is structurally invalid: no versions, an `id`
+ * that is not the first version's `currentHash` (identity is content-addressed
+ * to the first version), a `head` that does not match the latest version, or an
+ * out-of-range `gasLimit`.
+ */
+class LibraryEntityInvalidError extends base_error_1.BaseError {
+    constructor(reason) {
+        super(`Library entity invalid: ${reason}.`);
+        this.reason = reason;
+    }
+}
+exports.LibraryEntityInvalidError = LibraryEntityInvalidError;

package/dist/errors/settlement/settlement-errors.d.ts

@@ -0,0 +1,74 @@
+import { BaseError } from '../base-error';
+import { SettlementPhase } from '../../models/settlement/settlement-models';
+/**
+ * Thrown when a settlement leg's target block has advanced since the leg was
+ * signed. The leg's `againstHash` no longer matches the block's current-state
+ * hash, so reserving against it would bind a stale transition (D5 drift
+ * guard). The orchestrator treats this as a reserve failure and aborts the
+ * whole settlement.
+ */
+export declare class SettlementLegDriftError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    readonly expectedHash: string;
+    readonly actualHash: string;
+    constructor(settlementId: string, blockId: string, expectedHash: string, actualHash: string);
+}
+/**
+ * Thrown when a coordinator phase transition is illegal under the 2PC graph
+ * (e.g. `PREPARING → COMMITTED` skipping `COMMITTING`, or any move out of a
+ * terminal phase). Enforced by `buildSettlementPhaseRule`.
+ */
+export declare class SettlementPhaseError extends BaseError {
+    readonly settlementId: string;
+    readonly fromPhase: SettlementPhase;
+    readonly toPhase: SettlementPhase;
+    constructor(settlementId: string, fromPhase: SettlementPhase, toPhase: SettlementPhase);
+}
+/**
+ * Thrown when a settlement tries to reserve against a block that already holds
+ * a different, conflicting reservation under the same `settlementId`. (A
+ * re-drive with identical terms is idempotent and is not a conflict.)
+ */
+export declare class SettlementReservationConflictError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    constructor(settlementId: string, blockId: string);
+}
+/**
+ * Thrown when an operation references a leg (by `blockId`) that is not part of
+ * the settlement's plan.
+ */
+export declare class SettlementLegNotFoundError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    constructor(settlementId: string, blockId: string);
+}
+/**
+ * Thrown when a mutating operation targets a settlement already in a terminal
+ * phase (`COMMITTED` or `ABORTED`). The journal says it finished; it cannot be
+ * reopened.
+ */
+export declare class SettlementAlreadyTerminalError extends BaseError {
+    readonly settlementId: string;
+    readonly phase: SettlementPhase;
+    constructor(settlementId: string, phase: SettlementPhase);
+}
+/**
+ * Thrown when a leg's block-side reserve does not take hold — the member block
+ * refused the PREPARE. The reserve function no-ops (returns `current`) on an
+ * overdraw, a closed block, a currency mismatch, or malformed input, and the
+ * rule engine can reject a crafted proposal; in every case the post-condition
+ * (`reservations[settlementId]` present and matching the leg) is unmet. The
+ * in-process executor surfaces that as this error, which the orchestrator
+ * treats as a reserve failure and aborts the whole settlement. `reason` carries
+ * human-readable context (the underlying cause cannot always be distinguished
+ * from a no-op flag alone).
+ */
+export declare class SettlementLegReserveFailedError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    readonly reason: string;
+    constructor(settlementId: string, blockId: string, reason: string);
+}
+//# sourceMappingURL=settlement-errors.d.ts.map

package/dist/errors/settlement/settlement-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlement-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/settlement/settlement-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAE5E;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,UAAU,EAAE,MAAM,CAAC;gBAEvB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAS9F;AAED;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAC/C,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,SAAS,EAAE,eAAe,CAAC;IAC3C,SAAgB,OAAO,EAAE,eAAe,CAAC;gBAE7B,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe;CAQzF;AAED;;;;GAIG;AACH,qBAAa,kCAAmC,SAAQ,SAAS;IAC7D,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAEpB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAOpD;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;IACrD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAEpB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAOpD;AAED;;;;GAIG;AACH,qBAAa,8BAA+B,SAAQ,SAAS;IACzD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,KAAK,EAAE,eAAe,CAAC;gBAE3B,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe;CAO3D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,+BAAgC,SAAQ,SAAS;IAC1D,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQpE"}

package/dist/errors/settlement/settlement-errors.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettlementLegReserveFailedError = exports.SettlementAlreadyTerminalError = exports.SettlementLegNotFoundError = exports.SettlementReservationConflictError = exports.SettlementPhaseError = exports.SettlementLegDriftError = void 0;
+const base_error_1 = require("../base-error");
+/**
+ * Thrown when a settlement leg's target block has advanced since the leg was
+ * signed. The leg's `againstHash` no longer matches the block's current-state
+ * hash, so reserving against it would bind a stale transition (D5 drift
+ * guard). The orchestrator treats this as a reserve failure and aborts the
+ * whole settlement.
+ */
+class SettlementLegDriftError extends base_error_1.BaseError {
+    constructor(settlementId, blockId, expectedHash, actualHash) {
+        super(`Settlement ${settlementId}: block ${blockId} drifted — leg signed against ${expectedHash}, block is now ${actualHash}.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+        this.expectedHash = expectedHash;
+        this.actualHash = actualHash;
+    }
+}
+exports.SettlementLegDriftError = SettlementLegDriftError;
+/**
+ * Thrown when a coordinator phase transition is illegal under the 2PC graph
+ * (e.g. `PREPARING → COMMITTED` skipping `COMMITTING`, or any move out of a
+ * terminal phase). Enforced by `buildSettlementPhaseRule`.
+ */
+class SettlementPhaseError extends base_error_1.BaseError {
+    constructor(settlementId, fromPhase, toPhase) {
+        super(`Settlement ${settlementId}: illegal phase transition ${fromPhase} → ${toPhase}.`);
+        this.settlementId = settlementId;
+        this.fromPhase = fromPhase;
+        this.toPhase = toPhase;
+    }
+}
+exports.SettlementPhaseError = SettlementPhaseError;
+/**
+ * Thrown when a settlement tries to reserve against a block that already holds
+ * a different, conflicting reservation under the same `settlementId`. (A
+ * re-drive with identical terms is idempotent and is not a conflict.)
+ */
+class SettlementReservationConflictError extends base_error_1.BaseError {
+    constructor(settlementId, blockId) {
+        super(`Settlement ${settlementId}: block ${blockId} already has a conflicting reservation for this settlement.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+    }
+}
+exports.SettlementReservationConflictError = SettlementReservationConflictError;
+/**
+ * Thrown when an operation references a leg (by `blockId`) that is not part of
+ * the settlement's plan.
+ */
+class SettlementLegNotFoundError extends base_error_1.BaseError {
+    constructor(settlementId, blockId) {
+        super(`Settlement ${settlementId}: no leg for block ${blockId} in the plan.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+    }
+}
+exports.SettlementLegNotFoundError = SettlementLegNotFoundError;
+/**
+ * Thrown when a mutating operation targets a settlement already in a terminal
+ * phase (`COMMITTED` or `ABORTED`). The journal says it finished; it cannot be
+ * reopened.
+ */
+class SettlementAlreadyTerminalError extends base_error_1.BaseError {
+    constructor(settlementId, phase) {
+        super(`Settlement ${settlementId}: already terminal (${phase}); no further transitions allowed.`);
+        this.settlementId = settlementId;
+        this.phase = phase;
+    }
+}
+exports.SettlementAlreadyTerminalError = SettlementAlreadyTerminalError;
+/**
+ * Thrown when a leg's block-side reserve does not take hold — the member block
+ * refused the PREPARE. The reserve function no-ops (returns `current`) on an
+ * overdraw, a closed block, a currency mismatch, or malformed input, and the
+ * rule engine can reject a crafted proposal; in every case the post-condition
+ * (`reservations[settlementId]` present and matching the leg) is unmet. The
+ * in-process executor surfaces that as this error, which the orchestrator
+ * treats as a reserve failure and aborts the whole settlement. `reason` carries
+ * human-readable context (the underlying cause cannot always be distinguished
+ * from a no-op flag alone).
+ */
+class SettlementLegReserveFailedError extends base_error_1.BaseError {
+    constructor(settlementId, blockId, reason) {
+        super(`Settlement ${settlementId}: reserve failed for block ${blockId} — ${reason}.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+        this.reason = reason;
+    }
+}
+exports.SettlementLegReserveFailedError = SettlementLegReserveFailedError;

package/dist/errors/share-data/share-data-errors.d.ts

@@ -1,6 +1,19 @@
+import { z } from 'zod';
 import { BaseError } from '../base-error';
 import { ShareDataTypes } from '../../models/share-data/share-data-models';
 import { IShareDataFunction } from '../../models/functions/share-data-function-models';
+/**
+ * Thrown when a share function's runtime input fails its declared
+ * `inputSchema` (input well-formedness). Distinct from a stateful no-op: a
+ * malformed input is a caller/attacker error, surfaced explicitly rather than
+ * collapsed into a silent "no change". Carries the function id and the Zod
+ * issue list so callers (and HTTP layers) can render a precise rejection.
+ */
+export declare class ShareFunctionInputInvalidError extends BaseError {
+    readonly functionId?: string;
+    readonly issues: z.ZodError['issues'];
+    constructor(functionId: string | undefined, error: z.ZodError);
+}
 /**
  * This error is thrown when a function is tried to be applied to the share data thats state is locked.
  */
@@ -19,6 +32,14 @@ export declare class ShareDataCurrentAndProposalDataMatchesError extends BaseErr
      */
     constructor(shareDataId: string);
 }
+/**
+ * Thrown when a block carries library rule references but no library store has
+ * been injected to resolve them. Fail-closed: rather than silently skip the
+ * governing rules, evaluation refuses to proceed.
+ */
+export declare class ShareDataLibraryStoreNotSetError extends BaseError {
+    constructor(shareDataId: string);
+}
 /**
  * This error is thrown when the share data integrity check fails.
  */

package/dist/errors/share-data/share-data-errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"share-data-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/share-data/share-data-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACjD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc;CAGjE;AAED;;GAEG;AACH,qBAAa,2CAA4C,SAAQ,SAAS;IACtE;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,yDAA0D,SAAQ,SAAS;IACpF;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI5E;AAGD;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;IACxD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM;CAIjG;AAKD;;GAEG;AACH,qBAAa,yCAA0C,SAAQ,SAAS;IACpE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;IACrE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAID;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,SAAS;gBAC1C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;gBACrC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;gBACtC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,iCAAkC,SAAQ,SAAS;gBAChD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,6CAA8C,SAAQ,SAAS;gBAC5D,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,SAAS;gBAC9C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;gBACzD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,SAAS;gBAClD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,oCAAqC,SAAQ,SAAS;gBACnD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;CAM5D;AAED;;;;;;;;;GASG;AACH,qBAAa,qCAAsC,SAAQ,SAAS;gBACpD,WAAW,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM;CAOhE;AAED;;;GAGG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM;CAIlC;AAED;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;gBACxC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAGlD"}
+{"version":3,"file":"share-data-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/share-data/share-data-errors.ts"],"names":[],"mappings":"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"}

package/dist/errors/share-data/share-data-errors.js

@@ -1,7 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShareDataPersistenceError = exports.ShareDataPreviousHashNotAvailableError = exports.ShareDataDelegationNotAuthorizedError = exports.ShareDataTransactionNotAuthorizedError = exports.ShareDataTransactionProofFailedError = exports.ShareDataStructuralProofFailedError = exports.ShareDataStructuralProofAlreadyExistsError = exports.ShareDataCryptoProofFailedError = exports.CryptoInitializationPublicKeyIsDifferentError = exports.ShareDataCryptoAlreadyExistsError = exports.ShareDataDuplicateError = exports.ShareDataNotFoundError = exports.ShareDataAlreadyExistsError = exports.ShareRuleProposedConditionsNotPresentError = exports.ShareRuleCurrentConditionsNotPresentError = exports.ShareDataFunctionHashNotValid = exports.ShareDataFunctionBeingAppliedDoesNotExistOnShareDataError = exports.ShareDataIntegrityError = exports.ShareDataCurrentAndProposalDataMatchesError = exports.ShareDataIsLockedError = void 0;
+exports.ShareDataPersistenceError = exports.ShareDataPreviousHashNotAvailableError = exports.ShareDataDelegationNotAuthorizedError = exports.ShareDataTransactionNotAuthorizedError = exports.ShareDataTransactionProofFailedError = exports.ShareDataStructuralProofFailedError = exports.ShareDataStructuralProofAlreadyExistsError = exports.ShareDataCryptoProofFailedError = exports.CryptoInitializationPublicKeyIsDifferentError = exports.ShareDataCryptoAlreadyExistsError = exports.ShareDataDuplicateError = exports.ShareDataNotFoundError = exports.ShareDataAlreadyExistsError = exports.ShareRuleProposedConditionsNotPresentError = exports.ShareRuleCurrentConditionsNotPresentError = exports.ShareDataFunctionHashNotValid = exports.ShareDataFunctionBeingAppliedDoesNotExistOnShareDataError = exports.ShareDataIntegrityError = exports.ShareDataLibraryStoreNotSetError = exports.ShareDataCurrentAndProposalDataMatchesError = exports.ShareDataIsLockedError = exports.ShareFunctionInputInvalidError = void 0;
 const base_error_1 = require("../base-error");
+/**
+ * Thrown when a share function's runtime input fails its declared
+ * `inputSchema` (input well-formedness). Distinct from a stateful no-op: a
+ * malformed input is a caller/attacker error, surfaced explicitly rather than
+ * collapsed into a silent "no change". Carries the function id and the Zod
+ * issue list so callers (and HTTP layers) can render a precise rejection.
+ */
+class ShareFunctionInputInvalidError extends base_error_1.BaseError {
+    constructor(functionId, error) {
+        const detail = error.issues
+            .map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`)
+            .join('; ');
+        super(`Input for share function ${functionId ?? '(anonymous)'} is invalid: ${detail}`);
+        this.functionId = functionId;
+        this.issues = error.issues;
+    }
+}
+exports.ShareFunctionInputInvalidError = ShareFunctionInputInvalidError;
 /**
  * This error is thrown when a function is tried to be applied to the share data thats state is locked.
  */
@@ -26,6 +44,17 @@ class ShareDataCurrentAndProposalDataMatchesError extends base_error_1.BaseError
     }
 }
 exports.ShareDataCurrentAndProposalDataMatchesError = ShareDataCurrentAndProposalDataMatchesError;
+/**
+ * Thrown when a block carries library rule references but no library store has
+ * been injected to resolve them. Fail-closed: rather than silently skip the
+ * governing rules, evaluation refuses to proceed.
+ */
+class ShareDataLibraryStoreNotSetError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} has rule references but no library store set to resolve them.`);
+    }
+}
+exports.ShareDataLibraryStoreNotSetError = ShareDataLibraryStoreNotSetError;
 /**
  * This error is thrown when the share data integrity check fails.
  */

package/dist/helpers/apply-share-function.d.ts

@@ -0,0 +1,23 @@
+import { IShareFunction } from '../models/share-data/share-data-models';
+/**
+ * Validates a share function's runtime input against its declared
+ * `inputSchema`, if any. Opt-in: a function with no schema is not checked.
+ * Throws {@link ShareFunctionInputInvalidError} (carrying the function id and
+ * the Zod issues) on a malformed input — input well-formedness only; stateful
+ * legality stays in `func` / the rule engine.
+ */
+export declare const validateShareFunctionInput: (fn: Pick<IShareFunction<unknown, any, unknown>, "id" | "inputSchema">, input: unknown) => void;
+/**
+ * The single place a share function turns an `input` into a proposed state:
+ * validate the input first (throwing on malformed), then run `func`. Both
+ * application points (`safeSubmitTransaction` and the manager proposer) route
+ * through here, so the input contract cannot be silently bypassed.
+ */
+export declare const applyShareFunction: <TState, TInput>(fn: IShareFunction<{
+    current: TState;
+    input: TInput;
+}, (args: {
+    current: TState;
+    input: TInput;
+}) => TState, TState>, current: TState, input: TInput) => TState;
+//# sourceMappingURL=apply-share-function.d.ts.map

package/dist/helpers/apply-share-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-share-function.d.ts","sourceRoot":"","sources":["../../src/helpers/apply-share-function.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAExE;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GACnC,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,IAAI,GAAG,aAAa,CAAC,EACrE,OAAO,OAAO,KACf,IAQF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,EAAE,MAAM,EAC7C,IAAI,cAAc,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAAK,MAAM,EAAE,MAAM,CAAC,EACpH,SAAS,MAAM,EACf,OAAO,MAAM,KACd,MAGF,CAAC"}

package/dist/helpers/apply-share-function.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyShareFunction = exports.validateShareFunctionInput = void 0;
+const share_data_errors_1 = require("../errors/share-data/share-data-errors");
+/**
+ * Validates a share function's runtime input against its declared
+ * `inputSchema`, if any. Opt-in: a function with no schema is not checked.
+ * Throws {@link ShareFunctionInputInvalidError} (carrying the function id and
+ * the Zod issues) on a malformed input — input well-formedness only; stateful
+ * legality stays in `func` / the rule engine.
+ */
+const validateShareFunctionInput = (fn, input) => {
+    if (!fn.inputSchema) {
+        return; // opt-in: no schema, no check
+    }
+    const result = fn.inputSchema.safeParse(input);
+    if (!result.success) {
+        throw new share_data_errors_1.ShareFunctionInputInvalidError(fn.id, result.error);
+    }
+};
+exports.validateShareFunctionInput = validateShareFunctionInput;
+/**
+ * The single place a share function turns an `input` into a proposed state:
+ * validate the input first (throwing on malformed), then run `func`. Both
+ * application points (`safeSubmitTransaction` and the manager proposer) route
+ * through here, so the input contract cannot be silently bypassed.
+ */
+const applyShareFunction = (fn, current, input) => {
+    (0, exports.validateShareFunctionInput)(fn, input);
+    return fn.func({ current, input });
+};
+exports.applyShareFunction = applyShareFunction;

package/dist/helpers/index.d.ts

@@ -1,6 +1,7 @@
 export * from './id-helpers';
 export * from './object-helpers';
 export * from './object-validation-helpers';
+export * from './apply-share-function';
 export * from './request/params-object-helpers';
 export * from './request/query-object-helpers';
 export * from './request/request-object-helpers';

package/dist/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAM5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AAKjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AAMvC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AAKjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC"}

package/dist/helpers/index.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./id-helpers"), exports);
 __exportStar(require("./object-helpers"), exports);
 __exportStar(require("./object-validation-helpers"), exports);
+__exportStar(require("./apply-share-function"), exports);
 // #endregion main exports
 // #region request exports
 __exportStar(require("./request/params-object-helpers"), exports);

package/dist/index.d.ts

@@ -5,5 +5,7 @@ export * from './authorization';
 export * from './crypto';
 export * from './errors';
 export * from './helpers';
+export * from './library';
 export * from './models';
+export * from './sandbox';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAM9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAM9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -25,4 +25,6 @@ __exportStar(require("./authorization"), exports);
 __exportStar(require("./crypto"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./library"), exports);
 __exportStar(require("./models"), exports);
+__exportStar(require("./sandbox"), exports);

package/dist/library/authorize-library.d.ts

@@ -0,0 +1,17 @@
+import { ILibraryDelegation, ILibraryEntity } from './library-models';
+/**
+ * Whether `delegation` is a genuine, owner-signed grant for this entity: its
+ * proof must be signed by the entity owner over the canonical, purpose-bound
+ * payload that binds the entity id and the granted key. A forged delegation
+ * entry (no valid owner signature) returns `false`.
+ */
+export declare const isValidLibraryDelegation: (entity: ILibraryEntity, delegation: ILibraryDelegation) => boolean;
+/**
+ * Whether `publicKey` may append a version to `entity`: the owner is always
+ * authorized; a delegated key is authorized only if it carries a valid,
+ * owner-signed delegation. This is the single predicate behind the append gate
+ * and the per-version authorization check in `verifyLibraryEntity`, so the live
+ * and verify paths cannot drift.
+ */
+export declare const isLibraryAuthorizedSigner: (entity: ILibraryEntity, publicKey: string) => boolean;
+//# sourceMappingURL=authorize-library.d.ts.map

package/dist/library/authorize-library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize-library.d.ts","sourceRoot":"","sources":["../../src/library/authorize-library.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGtE;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACjC,QAAQ,cAAc,EACtB,YAAY,kBAAkB,KAC/B,OAYF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GAAI,QAAQ,cAAc,EAAE,WAAW,MAAM,KAAG,OAQrF,CAAC"}

package/dist/library/authorize-library.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLibraryAuthorizedSigner = exports.isValidLibraryDelegation = void 0;
+const verify_ed25519_signature_1 = require("../crypto/signature/verify-ed25519-signature");
+const library_proof_1 = require("./library-proof");
+/**
+ * Whether `delegation` is a genuine, owner-signed grant for this entity: its
+ * proof must be signed by the entity owner over the canonical, purpose-bound
+ * payload that binds the entity id and the granted key. A forged delegation
+ * entry (no valid owner signature) returns `false`.
+ */
+const isValidLibraryDelegation = (entity, delegation) => {
+    // Only the owner may delegate; the proof must be the owner's signature.
+    if (delegation.proof.publicKey !== entity.owner.publicKey) {
+        return false;
+    }
+    const payload = (0, library_proof_1.buildDelegationProofPayload)({
+        id: entity.id,
+        signerPublicKey: delegation.signerPublicKey,
+        purpose: (0, library_proof_1.delegatePurpose)(entity.kind),
+        publicKey: entity.owner.publicKey,
+    });
+    return (0, verify_ed25519_signature_1.verifyEd25519Signature)(entity.owner.publicKey, payload, delegation.proof.signature);
+};
+exports.isValidLibraryDelegation = isValidLibraryDelegation;
+/**
+ * Whether `publicKey` may append a version to `entity`: the owner is always
+ * authorized; a delegated key is authorized only if it carries a valid,
+ * owner-signed delegation. This is the single predicate behind the append gate
+ * and the per-version authorization check in `verifyLibraryEntity`, so the live
+ * and verify paths cannot drift.
+ */
+const isLibraryAuthorizedSigner = (entity, publicKey) => {
+    if (publicKey === entity.owner.publicKey) {
+        return true;
+    }
+    return entity.delegations.some((delegation) => delegation.signerPublicKey === publicKey && (0, exports.isValidLibraryDelegation)(entity, delegation));
+};
+exports.isLibraryAuthorizedSigner = isLibraryAuthorizedSigner;

package/dist/library/build-library.d.ts

@@ -0,0 +1,49 @@
+import { ILibraryEntity, LibraryEntityKind } from './library-models';
+export interface CreateLibraryEntityArgs {
+    kind: LibraryEntityKind;
+    name: string;
+    description: string;
+    gasLimit: number;
+    /** The stringified function/rule source for the first version. */
+    source: string;
+    /** 32-byte Ed25519 secret seed (hex) — becomes the entity owner. */
+    privateKey: string;
+    /** Defaults to `Date.now()`. Signed, but not part of the content hash. */
+    createdAt?: number;
+}
+export interface AppendLibraryVersionArgs {
+    source: string;
+    privateKey: string;
+    createdAt?: number;
+}
+/**
+ * Creates a new library entity from its first version. The entity `id` is the
+ * first version's `currentHash` (content-addressed identity); the signing key
+ * becomes the entity owner.
+ */
+export declare const createLibraryEntity: (args: CreateLibraryEntityArgs) => ILibraryEntity;
+export interface AddLibraryDelegateArgs {
+    /** The key being granted append rights. */
+    signerPublicKey: string;
+    /** Must be the entity owner's private key — only the owner may delegate. */
+    ownerPrivateKey: string;
+    createdAt?: number;
+}
+/**
+ * Grants `signerPublicKey` the right to append versions, signed by the owner.
+ * Returns a new entity (the input is not mutated). Rejects with
+ * {@link LibraryDelegationNotAuthorizedError} if the signing key is not the
+ * owner (which also blocks a delegate from re-delegating — a delegate's key is
+ * never the owner key) or if the grant targets the owner itself.
+ */
+export declare const addLibraryDelegate: (entity: ILibraryEntity, args: AddLibraryDelegateArgs) => ILibraryEntity;
+/**
+ * Appends a new signed version to an entity's ledger and returns a new entity
+ * (the input is not mutated). The new version chains to the prior tip via
+ * `previousHash`, and a fresh head proof is minted over the new tip.
+ *
+ * Gated: the signer must be the owner or a verified delegate
+ * ({@link isLibraryAuthorizedSigner}), else {@link LibraryVersionNotAuthorizedError}.
+ */
+export declare const appendLibraryVersion: (entity: ILibraryEntity, args: AppendLibraryVersionArgs) => ILibraryEntity;
+//# sourceMappingURL=build-library.d.ts.map

package/dist/library/build-library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-library.d.ts","sourceRoot":"","sources":["../../src/library/build-library.ts"],"names":[],"mappings":"AASA,OAAO,EAEH,cAAc,EAGd,iBAAiB,EAGpB,MAAM,kBAAkB,CAAC;AAU1B,MAAM,WAAW,uBAAuB;IACpC,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAiDD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,uBAAuB,KAAG,cAuBnE,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACnC,2CAA2C;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,4EAA4E;IAC5E,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC3B,QAAQ,cAAc,EACtB,MAAM,sBAAsB,KAC7B,cAqBF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC7B,QAAQ,cAAc,EACtB,MAAM,wBAAwB,KAC/B,cAeF,CAAC"}