@patterkit/runtime 0.12.1 → 0.13.0

package/CHANGELOG.md

@@ -33,6 +33,21 @@ version number always means the same runtime behaviour. This package is versione
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-09-05
+
+### Changed
+
+- **A `writable: false` host declaration is the STORY's promise, and only the story's: the game
+  writes it.** `Engine.setProperty` / `Flow.setProperty` are the game's surfaces, so they now write a
+  read-only `@world` property whether it is self-backed or bound to a resolver; an effect that writes
+  one is refused exactly as before, with the same sentence. Until now the runtime refused every
+  caller alike, so a game could not advance its own clock through the engine and a Patterplay
+  coverage driver on such a property killed the run - which is how both this project and the
+  Storylet Engine found it, on the same day, in different content
+  (from-storylets/host-writes-to-read-only-world). The rule now lives in the shared kernel
+  (`@wildwinter/scoperegistry` ^0.6.0, an explicit host authority on `set`), so both products mean
+  the same thing by the flag.
+
 ## [0.12.1] - 2026-09-04
 
 ### Changed

package/dist/index.cjs

@@ -536,10 +536,16 @@ var Engine = class _Engine {
     const { scope, name } = this.splitShared(ref);
     return this.host.shared.get(scope, name);
   }
-  /** Write a shared (`@patter` / foreign) property by ref. `@scene` refs are rejected (flow-level). */
+  /** Write a shared (`@patter` / foreign) property by ref. `@scene` refs are rejected (flow-level).
+   *
+   *  This is the GAME's surface, so it writes with host authority: a host-scope declaration's
+   *  `writable: false` is the story's promise not to write the value, never a lock on the game that
+   *  owns it. The story's own writes come through `Flow.runEffects`, which never claims it. (Ruled
+   *  across the family 2026-09-05, after a Storylets venue clock and this project's coverage driver
+   *  were each refused the one property they existed to move.) */
   setProperty(ref, value) {
     const { scope, name } = this.splitShared(ref);
-    this.host.shared.set(scope, name, value);
+    this.host.shared.set(scope, name, value, { host: true });
   }
   /** The shared `@patter` properties, for a live state inspector: each with its ref, type, current
    *  value, declared default (for reset), and enum options. Mirrors the Unity / Godot ports. */
@@ -1006,8 +1012,15 @@ var Flow = class {
     if (scope === "scene") return this.sceneResolver.get(name);
     return this.host.shared.get(scope, name);
   }
-  /** Write a property by ref (routed by scope, then by the property's `shared` flag). */
+  /** Write a property by ref (routed by scope, then by the property's `shared` flag). The GAME's
+   *  surface: it writes with host authority, so a `writable: false` host declaration does not refuse
+   *  it (see `Engine.setProperty`). The story's writes go through `writeProperty` instead. */
   setProperty(ref, value) {
+    this.writeProperty(ref, value, true);
+  }
+  /** The write itself. `host` says WHO is writing, which is the only thing `writable: false` cares
+   *  about: the story is refused, the game is not. */
+  writeProperty(ref, value, host) {
     const { scope, name } = this.splitRef(ref);
     if (scope === "patter") {
       this.patterResolver.set(name, value);
@@ -1015,7 +1028,7 @@ var Flow = class {
       if (this.currentSceneId === null) throw new Error(`'${ref}': the flow has not entered a scene yet`);
       this.sceneResolver.set(name, value);
     } else {
-      this.host.shared.set(scope, name, value);
+      this.host.shared.set(scope, name, value, host ? { host: true } : void 0);
     }
   }
   // -- Save / restore (engine-driven) --------------------------------------
@@ -1359,7 +1372,7 @@ var Flow = class {
     for (const e of effects ?? []) {
       const value = this.evalExpr(e.value);
       const prev = this.host.logEnabled ? this.getProperty(e.target) : void 0;
-      this.setProperty(e.target, value);
+      this.writeProperty(e.target, value, false);
       this.emit({ type: "write", target: e.target, value, ...prev !== void 0 ? { prev } : {} });
     }
   }