kopular 1.3.0 → 1.3.2

package/GUIDE.md

@@ -25,6 +25,12 @@ hint — so running a separate build before it only adds a round-trip (the build
 well under a second). `ks check src/app.ks` type-checks without building, for when you only
 want the errors.
 
+**A fresh `kp new` project's `src/` is exactly three files, all shown in this guide:**
+`app.ks` (the block above), `counter.ks` (the `Counter` class under Components, plus
+`using "kopular";`), and `counter.html` (its template, right below it). `index.html` already
+maps every Kopular module and never needs editing. There's nothing else to discover — read
+the task, then write your files.
+
 ## The language you need
 
 - `Type name = value;` for every local — no `let`/`var`, no inference on declarations.
@@ -102,9 +108,11 @@ class Counter : Component {
 <button (click)="Increment()">Count: {{ Count.Value }}</button>
 ```
 
-`state<T>` referenced directly in a template auto-subscribes — no manual `Subscribe`
-needed. State reached *indirectly* (through a method, or `this.SomeService.Count`) does
-need one: `this.SomeService.Count.Subscribe((v) => this.Update());` in the constructor.
+A `state<T>` field the template reads auto-subscribes — no manual `Subscribe` needed —
+whether it's named directly (`{{ Count.Value }}`) or read through the component's own
+methods (`*for="Todo t of Visible()"`, `{{ CountText() }}`, followed transitively). Event
+handlers don't count. State on *another* object does still need one:
+`this.SomeService.Count.Subscribe((v) => this.Update());` in the constructor.
 
 **Template bindings**: `{{ expr }}` text, `[prop]="expr"` (real fields for
 `id`/`className`/`value`/`disabled`/`checked`; anything else is a plain attribute),

package/LLM.md

@@ -451,11 +451,12 @@ class Counter : Component {
   component composition" below). Unlike `*if`/`*for`, it composes with either — `*for="Row
   r of Rows" *mount="r"` (one mounted child per loop item) is the headline case, not an
   error. See kopscript's own `LLM.md`/`README.md` for the full syntax.
-- A `state<T>` field declared directly on the class and referenced directly in the
-  template (`Count` above) gets `Subscribe((v) => this.Update())` wired automatically —
-  no manual `Subscribe` in the constructor for that field. State reached indirectly
-  (through a method, or `this.SomeService.Count`) still needs a manual `Subscribe`, same
-  as a hand-written `Render()` always has.
+- A `state<T>` field declared on the class gets `Subscribe((v) => this.Update())` wired
+  automatically when the template reads it — directly (`Count` above) or through the
+  class's own methods a render-time binding calls, followed transitively
+  (`*for="Todo t of Visible()"`). Event handlers aren't followed. State on another object
+  (`this.SomeService.Count`) still needs a manual `Subscribe`, as does any hand-written
+  `Render()`.
 - **Two-way binding**: `[(value)]="Field"` desugars to `[value]="Field"` +
   `(input)="Field = e.target.value"` — `value` only, and `Field` must be a bare name or
   `this.Field` (see KopScript's own LLM.md `KS5017`/`KS5018` for the two rejected cases).

package/README.md

@@ -33,8 +33,8 @@ Generating Kopular code with an AI coding assistant? Point it at **[`LLM.md`](./
   `.html` file — interpolation (`{{ }}`), event/property bindings (`(click)="..."`,
   `[prop]="..."`), and `*if`/`*for` structural directives — desugared by the KopScript
   compiler into the exact same code a hand-written `Render()` would produce, with
-  automatic `Subscribe`/`Update()` wiring for `state<T>` fields referenced directly in the
-  markup. See "Templates" below.
+  automatic `Subscribe`/`Update()` wiring for the `state<T>` fields the markup reads,
+  directly or through the component's own methods. See "Templates" below.
 - **Reactive state, no RxJS**: components hold `state<number>`/`state<string>`/... (a
   KopScript language feature — see the [KopScript](https://dev.azure.com/koppinator/Koppindependence/_git/KopScript)
   repo) and subscribe once, in their constructor, to call `Update()` on change. No
@@ -137,9 +137,8 @@ class Counter : Component {
 
 Both produce the same `Render()`, and can be mixed freely across a codebase — nothing
 about `Component`, `Update()`, or any other Kopular API differs between them. The manual
-`Subscribe` call is still exactly what you need the moment state is reached *indirectly*
-— through a method call, or through an injected service's own state
-(`this.Service.Count`, say) — which is why the real, production `Counter` on the
+`Subscribe` call is still exactly what you need the moment state lives on *another*
+object — an injected service's own state (`this.Service.Count`, say) — which is why the real, production `Counter` on the
 [KopularDemo](https://dev.azure.com/koppinator/Koppindependence/_git/KopularDemo) site
 (it injects a `CounterService` rather than holding `Count` itself) uses a template but
 still has one manual `Subscribe`. `*if`/`*for` in a template are covered under

package/bin/kp.mjs

@@ -180,15 +180,8 @@ const COUNTER_KS_TEMPLATE = `using "kopular";
 
 class Counter : Component {
   public state<number> Count;
-
-  constructor() : base() {
-    this.Count = state(0);
-  }
-
-  public void Increment() {
-    this.Count.Value = this.Count.Value + 1;
-  }
-
+  constructor() : base() { this.Count = state(0); }
+  public void Increment() { this.Count.Value = this.Count.Value + 1; }
   template from "./counter.html";
 }
 `;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kopular",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Kopular: a small component framework for KopScript — components, reactive state, constructor-injected services, routing, real compiled templates, and HTTP, with no DI container",
   "type": "module",
   "license": "MIT",
@@ -66,7 +66,7 @@
     "@types/jsdom": "^30.0.0",
     "@types/node": "^20.14.0",
     "jsdom": "^25.0.1",
-    "kopscript": "^1.1.0",
+    "kopscript": "^1.2.0",
     "typescript": "^5.5.0",
     "vitest": "^4.1.11"
   },