@executablemd/durable-streams 0.11.0 → 0.12.1

package/esm/guard.js

@@ -48,7 +48,7 @@ export function establishJournalProvenance(stream) {
 /**
  * Carry an exact source stream's provenance onto a trusted wrapper of it.
  *
- * Preservation is visible composition rather than new authority: it transfers
+ * Preservation is visible composition rather than a new claim: it transfers
  * only the witness already associated with that exact source, so an unproven
  * source leaves the target unproven. The target is returned so the wrapping
  * site reads as one expression.
@@ -57,7 +57,7 @@ export function preserveJournalProvenance(source, target) {
     journalProvenances.preserve(source, target);
     return target;
 }
-/** @internal The live durable path reads provenance without receiving stream authority. */
+/** @internal The live durable path reads provenance without receiving the stream itself. */
 export function getJournalProvenance(stream) {
     return journalProvenances.get(stream);
 }

package/esm/position.js

@@ -21,12 +21,12 @@
  * — which is what makes the index a coroutine reaches at one point in its
  * procedure the same index it reaches there next time.
  *
- * ## Observation, never authority
+ * ## Observation, never enforcement
  *
  * A position describes where execution is. It authorizes nothing, proves
  * nothing about who is executing, and is not durable state: it is derived by
  * counting what the journal already holds. Anything that must be trusted is
- * checked by whoever owns the authority to check it.
+ * checked by whoever owns the decision to check it.
  */
 import { DurableContext } from "./context.js";
 /**

package/esm/replay-guard.js

@@ -12,7 +12,7 @@
  * (e.g., content hash, status code). There is no separate metadata field —
  * inputs belong in the effect description, outputs belong in the result.
  *
- * A guard is **composable policy, not authority**. Guards compose through
+ * A guard is **composable policy, not enforcement**. Guards compose through
  * `Api.around`, and a handler installed further out may decline to call `next`.
  * That is what composition is for, and it is why an invariant that must not be
  * negotiable — durable identity above all — belongs somewhere a caller cannot

package/esm/retained.js

@@ -2,7 +2,7 @@
  * Retained events — what a run reads a journal as.
  *
  * A journal is data supplied by a backend, and every phase of a replay reads
- * the same events: a private authority gate, the replay index, public guard
+ * the same events: a private admission gate, the replay index, public guard
  * policy, and the replay path itself. If those are separate reads of the
  * backend's own objects, a source that answers differently between them decides
  * one thing for validation and another for execution, and nothing downstream
@@ -135,7 +135,7 @@ function detachResult(result) {
     if (status === "ok") {
         // Every successful shape, including the one that settled to nothing. A
         // `Result<void>` carries no value to detach, but the envelope is still
-        // authority — left writable, a caller of a public observation could add one
+        // the retained settlement — left writable, a caller of a public observation could add one
         // before replay reads it.
         if (!("value" in result)) {
             return Object.freeze({ status });
@@ -339,7 +339,7 @@ function isRetained(event) {
  * history the execution already validated: the authoritative graph is what
  * admission accepted and what replay consumes, and a guard that could rewrite a
  * root selection or an effect description after admission would hold exactly
- * the authority the private gate exists to keep out of public hands.
+ * the enforcement the private gate exists to keep out of public hands.
  *
  * So policy reads a copy. It is deep and mutable, so middleware may compose over
  * it as freely as it likes, and nothing it does reaches replay.
@@ -375,7 +375,7 @@ function observeDescription(description) {
  *
  * The authoritative copy is frozen so policy cannot rewrite it. A document
  * that resumes on a restored binding writes to it, so what a workflow receives
- * is a fresh copy taken from that authority rather than the authority itself.
+ * is a fresh copy taken from that retained history rather than the retained history itself.
  */
 export function consumable(result) {
     if (result.status === "ok") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@executablemd/durable-streams",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Durable, replayable event streams for executable.md.",
   "homepage": "https://executable.md",
   "repository": {

package/types/guard.d.ts

@@ -33,13 +33,13 @@ export declare function establishJournalProvenance(stream: DurableStream): Journ
 /**
  * Carry an exact source stream's provenance onto a trusted wrapper of it.
  *
- * Preservation is visible composition rather than new authority: it transfers
+ * Preservation is visible composition rather than a new claim: it transfers
  * only the witness already associated with that exact source, so an unproven
  * source leaves the target unproven. The target is returned so the wrapping
  * site reads as one expression.
  */
 export declare function preserveJournalProvenance(source: DurableStream, target: DurableStream): DurableStream;
-/** @internal The live durable path reads provenance without receiving stream authority. */
+/** @internal The live durable path reads provenance without receiving the stream itself. */
 export declare function getJournalProvenance(stream: DurableStream): JournalProvenance | undefined;
 export interface DurableEventRejectionOccurrence {
     rejected: boolean;

package/types/position.d.ts

@@ -21,12 +21,12 @@
  * — which is what makes the index a coroutine reaches at one point in its
  * procedure the same index it reaches there next time.
  *
- * ## Observation, never authority
+ * ## Observation, never enforcement
  *
  * A position describes where execution is. It authorizes nothing, proves
  * nothing about who is executing, and is not durable state: it is derived by
  * counting what the journal already holds. Anything that must be trusted is
- * checked by whoever owns the authority to check it.
+ * checked by whoever owns the decision to check it.
  */
 import { type Operation } from "effection";
 import type { CoroutineId } from "./types.js";

package/types/replay-guard.d.ts

@@ -12,7 +12,7 @@
  * (e.g., content hash, status code). There is no separate metadata field —
  * inputs belong in the effect description, outputs belong in the result.
  *
- * A guard is **composable policy, not authority**. Guards compose through
+ * A guard is **composable policy, not enforcement**. Guards compose through
  * `Api.around`, and a handler installed further out may decline to call `next`.
  * That is what composition is for, and it is why an invariant that must not be
  * negotiable — durable identity above all — belongs somewhere a caller cannot

package/types/retained.d.ts

@@ -2,7 +2,7 @@
  * Retained events — what a run reads a journal as.
  *
  * A journal is data supplied by a backend, and every phase of a replay reads
- * the same events: a private authority gate, the replay index, public guard
+ * the same events: a private admission gate, the replay index, public guard
  * policy, and the replay path itself. If those are separate reads of the
  * backend's own objects, a source that answers differently between them decides
  * one thing for validation and another for execution, and nothing downstream
@@ -67,7 +67,7 @@ export declare function retainEvents(events: readonly DurableEvent[]): DurableEv
  * history the execution already validated: the authoritative graph is what
  * admission accepted and what replay consumes, and a guard that could rewrite a
  * root selection or an effect description after admission would hold exactly
- * the authority the private gate exists to keep out of public hands.
+ * the enforcement the private gate exists to keep out of public hands.
  *
  * So policy reads a copy. It is deep and mutable, so middleware may compose over
  * it as freely as it likes, and nothing it does reaches replay.
@@ -78,6 +78,6 @@ export declare function observeEvent(event: DurableEvent): DurableEvent;
  *
  * The authoritative copy is frozen so policy cannot rewrite it. A document
  * that resumes on a restored binding writes to it, so what a workflow receives
- * is a fresh copy taken from that authority rather than the authority itself.
+ * is a fresh copy taken from that retained history rather than the retained history itself.
  */
 export declare function consumable(result: Result): Result;