@plitzi/sdk-shared 0.37.1 → 0.37.2

package/CHANGELOG.md

@@ -1,5 +1,147 @@
 # @plitzi/sdk-shared
 
+## 0.37.2
+
+### Patch Changes
+
+- ## Authoring and agents
+  - **A step's params are templates in full.** Only a bare name (`{{ post.slug }}`) used to be recognised, so a
+    condition or a loop in a `setState` or a webhook body was handed on as its own text — a flag set to
+    `{% if … %}1{% endif %}` stored the template, a non-empty string every later check read as true. Any `{{ }}` or
+    `{% %}` in a param is now evaluated; what it resolves to is data and is not evaluated again.
+  - **Twig tests work.** `x is defined`, `is empty`, `is null`, `is iterable`, `is even`, `is odd` (and `is not …`) used
+    to be read as comparisons with a variable of that name — `x is defined` answered true exactly when `x` was not
+    defined. Anything else on the right of `is` still compares.
+  - **A group takes an access chain.** `(rows|find('id', 3)).title` read the whole row; the key after the parenthesis
+    was never parsed.
+  - **An expression that chose to be empty renders empty** under `keepEmptyTokens`. A kept token is for a name still
+    waiting for a value; `{{ on ? 'active' : '' }}` said "nothing" on purpose, and handing back its text made the
+    empty branch a non-empty string.
+  - **Checkbox params written as text are booleans.** `dateConverter({ isUnix: 'false' })` read `'false'` as yes and
+    gave an ISO date back raw. Every utility's checkbox params are normalised before its callback runs.
+  - **`condition-starts-visible`** warns about a visibility computed from data on an element that starts on screen: it
+    is drawn until its provider answers and then hidden — an empty state or a "get started" card flashing past on
+    every load. `visible: false` makes it wait hidden. The export reads a visibility binding back in its place, so a
+    space whose condition is not its last binding round-trips unchanged.
+  - **A source named by its short id inside a binding's template is refused** with the full name, as it already was in
+    a flow: `{{ stats.total }}` resolved to nothing and the element showed its empty branch.
+  - **`activeOn(class, pageIds)`** marks a menu's current entry from `navigation.currentPageId` — one binding for a menu
+    kept in a layout. `variantFrom` now says `append: 'true'`, which is what it did.
+  - **Two elements with one id** name where the first one was written. **`template-never-resolved`** warns about a
+    condition left in an attribute, which only resolves `{{ name|filter }}` tokens.
+  - **The authoring skill is a folder**: `SKILL.md` plus references for layouts, data and visibility, templates,
+    flows, structure, testing and a review checklist. `plitzi create` copies all of it, and writes an `AGENTS.md`
+    (imported by `CLAUDE.md`) pointing any agent at it.
+
+  - **A new space starts on a page worth keeping.** The space `POST /spaces` and `plitzi create` both begin from is
+    redesigned: a top bar with the theme switch, a hero with two calls to action, and six guides — each a card linking to
+    its page of the docs (`https://plitzi.com/docs/…`). Every link used to be `#`, and one promised a course that does
+    not exist. The palette is a set of light/dark tokens in Geist, the guides are one list mapped to one card, and the
+    bands of the page share a `shell` class — the page is written the way the authoring skill asks a space to be.
+  - **The copy `plitzi create` writes passes its own project's lint.** An import of the package that would not fit
+    120 columns is wrapped one name per line, as the project's formatter would wrap it.
+
+  ## Server actions and scheduled jobs
+
+  **Scheduled jobs across replicas, out of the box, on the database a deployment already runs.** The scheduler and the
+  workers were already the package's; where the jobs wait was left to each deployment to write — and a queue is the part
+  that is easiest to get subtly wrong. Two helpers now build the adapters over a store the deployment owns, without the
+  package opening a connection or keeping data of its own:
+
+  - `@plitzi/sdk-server/mongo` — `createMongoJobQueue({ db })` and `createMongoKv({ db })`, over a `Db` (or a getter for a
+    client that reconnects). Creates the indexes its queries need; `mongodb` is an optional peer, used for its types.
+  - `@plitzi/sdk-server/mysql` — `createMysqlJobQueue({ pool })` and `createMysqlKv({ pool })`, over a `mysql2` pool.
+    Each job is claimed by a single-row compare-and-set, so replicas claiming at once never deadlock. Creates its three
+    tables on first use, or hands them to your own migrations through `mysqlJobSchemaStatements()`.
+
+  Every instant is the database server's, never a replica's. The in-process queue and both helpers pass one contract test
+  suite: exactly-once enqueue, atomic claims, leases that lapse and are reaped, heartbeats, settlements ignored from a
+  worker that lost its claim, refunded hand-backs, schedules advanced by compare-and-set, operator retry and cancel.
+
+  **`closeOnSignals(server, { afterClose })`** closes the server on SIGTERM/SIGINT and exits only once it has — so a
+  deploy finishes the jobs a replica is running and leaves the waiting ones for the next. A second signal exits at once.
+  Opt-in: a host with its own signal handling calls `server.close()` itself. Projects from `plitzi create` use it.
+
+  **A replica that is told to stop finishes the jobs it is running — and only those.** `server.close()` (and the job
+  worker's `stop()`) now waits for every running job to end however long past its lease that is, and keeps renewing
+  their claims while it waits. It used to stop renewing the moment the drain began and give up at the lease: a job longer
+  than its lease was taken over by another replica and run a second time while the first was still finishing it, and the
+  process exited in the middle of it. What is still waiting is not touched — it stays in the shared queue for the replica
+  that is staying or the one the deploy starts — and a job claimed in the instant the stop arrived is handed back with its
+  attempt refunded, never started. A run is bounded by its own timeout, which is the number an orchestrator's grace period
+  has to cover.
+
+  - **An every-minute schedule fired every other minute.** After producing a fire, the scheduler asked for the next
+    one from `lateness + 1 minute`, and `cronNextFire` rounds up to a whole minute — so a sweep that ran even a second
+    late (with the default 15-second sweep, nearly all of them) skipped the minute it should have produced. It now asks
+    from the minute after the one the sweep ran in. Only expressions with consecutive-minute fires were affected;
+    hourly and daily schedules were not.
+  - **A job that gives up says which step failed and why.** Its `error` and the failed attempt in its history used to
+    read "the flow ended failed" for every failure there is; they now read `step "<id>" failed: <message>`, taken from
+    the run's outline — already redacted of every credential the run resolved, so nothing reaches the job that the
+    run history would not show.
+  - **`apiContainer` takes `refreshSeconds`**: it asks again on its own every N seconds, for a page showing something
+    still moving — a queue, a feed, a status board. It is the same refresh `performQuery` runs, so it works for both
+    runtimes (a browser request is sent again; a server provider asks for its own RSC slice again). It pauses while
+    the tab is hidden and never starts a refresh while the last one is in flight. `0`, the default, never does. Before
+    this a live server provider needed a plugin element of its own to call `useRscRefresh` on a timer: `onApiSuccess`
+    never fires for a server provider, so there was no way to author the loop. The builder shows it as "Refresh every
+    (s)" for either runtime.
+  - **`onApiSuccess` / `onApiError` fire for a server provider.** The declaration offered them for every
+    `apiContainer`, but they were decided from the browser request alone — which a `runtime: 'server'` provider never
+    makes — so a flow wired to them never ran. They now fire when the provider's slice arrives (or the payload arrives
+    without it), and again on each refresh, the same as a browser refetch. A payload resolved for another page fires
+    neither. **A space that wired a flow to one of them will now see it run.**
+  - **The theme toggle shows one icon by default.** It renders both — which one is right depends on stored state, and
+    markup that depended on it would differ between the server and the browser — and until now every space had to copy
+    ten lines of `customCss` to hide the other; one that did not showed a sun and a moon side by side. The SDK's base
+    layer now shows the icon of the scheme in use, and a space's own rule still wins.
+  - **`variantFrom(cls, source)`** in `@plitzi/sdk-authoring` binds which of a CLASS's variants an element wears to a
+    value in the data — a status pill that is amber while a job waits and green once it is done. Written by hand the
+    variant key is the trap: it names the selector the variants belong to, and the element's type (`text.base`) is a
+    different selector from its class (`statusPill.base`), so the element rendered with no variant and nothing
+    reported it. The helper takes the key from the class declaration.
+  - **`authorSpace` refuses a flow template that reads a source by its short name.** A binding completes the prefix
+    (`jobRows.item.id` → `list_jobRows.item.id`), so the short form is the one an author learns first; a step's params
+    are read as written, and there it resolved to nothing — a row's button posted an empty id and every layer below
+    reported success. The error names the full source. A root that is a step of the same flow is left alone.
+  - New example, [`05-with-server-actions/05-schedules`](../examples/05-with-server-actions/05-schedules): scheduled and
+    delayed jobs on a self-hosted server, with the `ActionJobQueue` and `kv` seams written out in full over one SQLite
+    file, two replicas sharing it, failover when one is killed, and a board that watches it happen.
+
+  ## Rendering, data and styles
+  - **A server element inside a layout is resolved.** `collectServerElements` walked the page alone, so a
+    `runtime: 'server'` provider in a layout — a dashboard's sidebar, a section's header — was never resolved: the RSC
+    payload came back empty and the element rendered with nothing. It now walks the page and every shell in its layout
+    chain.
+  - **The twig `date` filter reads an epoch.** `new Date("1790143200000")` is Invalid Date, so an epoch in milliseconds
+    handed over as text — how an attribute passes one — formatted as nothing. A number, or a string of digits, is now
+    read as milliseconds.
+  - **An action is called by its name, not by its trigger kind.** `actionName` took the first trigger's title, and a
+    trigger nobody named is titled with its kind — so every rendered action in a workspace read "render" and every clock
+    "schedule". A title that only repeats the kind is no longer a name, and `defineAction` titles each trigger with the
+    action's name.
+  - **`variant` on an element that wears a class is that class's variant** when the class declares it and the type does
+    not. Keyed by the type, `text({ class: avatar, variant: 'violet' })` named `text--violet`, a selector nothing wears,
+    and rendered with no variant at all. Exporting a document back to authoring reads the same key back into `variant`.
+  - **`variantFrom` takes `{ slot, template }`**, where `template` turns a value into a variant name for data that does
+    not already speak in them — `"{{ source == 'code' ? 'on' : '' }}"`. The third argument was the slot name alone.
+  - **Entry declarations no longer alternate with `export {}`.** In `@plitzi/sdk-server` and `@plitzi/sdk-mcp` a repeated
+    `build:dev` left some `dist/<entry>.d.ts` as a ten-byte `export {}`, and consumers saw "has no exported member". The
+    cause was `insertTypesEntry` writing a types entry over the real declaration of the same path; it is gone.
+  - **Signing in keeps what a guest was doing.** `runtimeStatePersist` reset `runtime.state` whenever its owner changed,
+    and a guest becoming a user is a change — so a sign-in screen that remembered where to send somebody (`?redirect=`)
+    forgot it the moment the session arrived, and the sign-in ended on the fallback page instead. Only a change FROM an
+    account resets now: one account's state still never reaches the next, and a guest has no account to protect.
+
+  **A value with functions inside functions is written as it was given, and fast.** A CSS value was split into layers
+  at commas by a pattern that could only see one level of parentheses, so `var(--bg, light-dark(#fff, #111))` was cut at
+  its inner comma and half a function went on into the stylesheet. The half was then tokenised by an expression that
+  nested one quantifier inside another and backtracked exponentially on it — nearly two seconds for thirty characters,
+  on every generation of that selector's cache. Both are now one linear scan that splits only outside parentheses and
+  quotes. Generated caches keep the spacing the value was written with inside functions (`repeat(3, minmax(0, 1fr))`,
+  `color-mix(in oklab, oklch(…) 50%, transparent)`), where they used to drop it after the first comma.
+
 ## 0.37.1
 
 ### Patch Changes

package/dist/actions/cron.d.ts

@@ -10,25 +10,34 @@ type WallClock = {
     month: number;
     weekday: number;
 };
+export declare const zonedClock: (at: Date, timeZone: string) => WallClock | undefined;
+export declare const cronMatches: (expression: string, at: Date, timeZone?: string) => boolean;
 /**
- * The same instant, as the clock on a wall in `timeZone` reads it.
+ * The first minute at or after `from` that this expression fires on, or undefined when it never does.
+ *
+ * **This is what a schedule stores**, and why it is here rather than in a scheduler: a due time written into a row
+ * is a decision made once, by whoever wrote it, and every replica afterwards reads the same instant instead of each
+ * asking its own clock whether the moment has come. Nodes in different countries then disagree about what time it
+ * is — which they will — without ever disagreeing about which fires have happened.
  *
- * Through `Intl` rather than an offset table, because an offset is not a constant: "9am in Santiago" is a
- * different instant in January and in July, and a schedule that means the working day has to follow the change.
- * `hourCycle: 'h23'` matters — the other cycles render midnight as 24, which cron has no hour for.
+ * Inclusive of `from`, so a caller that wants the one strictly after an instant asks from the minute after it. The
+ * search steps by whole minutes, skipping a day at a time when the date cannot match and an hour at a time when the
+ * hour cannot — a yearly expression costs a few hundred comparisons rather than half a million.
  *
- * An unknown zone answers `undefined` rather than falling back to UTC. Falling back is what this whole change is
- * about: a schedule that fires at the wrong hour and says nothing.
+ * DST is the reason the skips are computed from the WALL clock and then re-read rather than added as fixed offsets:
+ * jumping "to midnight" lands an hour early on the night a zone falls back, which costs one more comparison, and an
+ * hour late on the night it springs forward — into minutes that did not exist locally, so there was nothing there
+ * to miss.
  */
-export declare const zonedClock: (at: Date, timeZone: string) => WallClock | undefined;
+export declare const cronNextFire: (expression: string, from: Date, timeZone?: string) => Date | undefined;
 /**
- * Whether an expression fires at this minute — in `timeZone` when one is named, in UTC when none is.
+ * How many times an expression would have fired in `(after, until]`.
  *
- * Day-of-month and day-of-week are OR'd when both are restricted, which is the rule every cron implementation
- * follows and the one that surprises people who expect AND — `0 0 1 * 1` fires on the first of the month AND on
- * every Monday.
+ * What an operator is owed after an outage: the run that is about to happen is one fire, and this is the number of
+ * others that went by while nothing was there to take them. Capped, because the answer's purpose is to be shown to
+ * somebody — a minutely schedule down for a week is "at least `limit`", not a number worth spending a second on.
  */
-export declare const cronMatches: (expression: string, at: Date, timeZone?: string) => boolean;
+export declare const cronFiresBetween: (expression: string, after: Date, until: Date, timeZone?: string, limit?: number) => number;
 /** Whether `Intl` knows this zone. The validator asks so an author hears about a typo in the editor. */
 export declare const isKnownTimeZone: (timeZone: string) => boolean;
 export {};

package/dist/actions/cron.mjs

@@ -37,17 +37,23 @@ var e = [
 	day: e.getUTCDate(),
 	month: e.getUTCMonth() + 1,
 	weekday: e.getUTCDay()
-}), a = (e, t) => {
+}), a = (e) => {
+	let t;
 	try {
-		let n = new Intl.DateTimeFormat("en-US", {
-			timeZone: t,
+		t = new Intl.DateTimeFormat("en-US", {
+			timeZone: e,
 			hourCycle: "h23",
 			month: "numeric",
 			day: "numeric",
 			hour: "numeric",
 			minute: "numeric",
 			weekday: "short"
-		}).formatToParts(e), i = (e) => n.find((t) => t.type === e)?.value ?? "", a = r.indexOf(i("weekday")), o = {
+		});
+	} catch {
+		return;
+	}
+	return (e) => {
+		let n = t.formatToParts(e), i = (e) => n.find((t) => t.type === e)?.value ?? "", a = r.indexOf(i("weekday")), o = {
 			minute: Number(i("minute")),
 			hour: Number(i("hour")),
 			day: Number(i("day")),
@@ -55,18 +61,43 @@ var e = [
 			weekday: a
 		};
 		return a >= 0 && Object.values(o).every(Number.isFinite) ? o : void 0;
-	} catch {
-		return;
+	};
+}, o = (e, t) => a(t)?.(e), s = ([, , e, t, n], r) => {
+	if (!t.has(r.month)) return !1;
+	let i = e.size !== 31, a = n.size !== 7, o = e.has(r.day), s = n.has(r.weekday);
+	return i && a ? o || s : o && s;
+}, c = (e, t) => {
+	let [n, r] = e;
+	return n.has(t.minute) && r.has(t.hour) && s(e, t);
+}, l = (e) => e ? a(e) : i, u = (e, t, r) => {
+	let i = n(e), a = i ? l(r)?.(t) : void 0;
+	return i !== void 0 && a !== void 0 && c(i, a);
+}, d = 6e4, f = 2108160 * d, p = (e, t, r) => {
+	let i = n(e), a = i ? l(r) : void 0;
+	if (!i || !a) return;
+	let o = Math.ceil(t.getTime() / d) * d, c = o + f, [u, p] = i;
+	for (let e = o; e <= c;) {
+		let t = new Date(e), n = a(t);
+		if (!n) return;
+		if (!s(i, n)) {
+			e += (1440 - n.hour * 60 - n.minute) * d;
+			continue;
+		}
+		if (!p.has(n.hour)) {
+			e += (60 - n.minute) * d;
+			continue;
+		}
+		if (u.has(n.minute)) return t;
+		e += d;
+	}
+}, m = (e, t, n, r, i = 1e3) => {
+	let a = 0, o = new Date(t.getTime() + d);
+	for (; a < i;) {
+		let t = p(e, o, r);
+		if (!t || t > n) return a;
+		a += 1, o = new Date(t.getTime() + d);
 	}
-}, o = (e, t, r) => {
-	let o = n(e);
-	if (!o) return !1;
-	let s = r ? a(t, r) : i(t);
-	if (!s) return !1;
-	let [c, l, u, d, f] = o;
-	if (!c.has(s.minute) || !l.has(s.hour) || !d.has(s.month)) return !1;
-	let p = u.size !== 31, m = f.size !== 7, h = u.has(s.day), g = f.has(s.weekday);
-	return p && m ? h || g : h && g;
-}, s = (e) => a(/* @__PURE__ */ new Date(), e) !== void 0;
+	return a;
+}, h = (e) => o(/* @__PURE__ */ new Date(), e) !== void 0;
 //#endregion
-export { o as cronMatches, s as isKnownTimeZone, n as parseCron, a as zonedClock };
+export { m as cronFiresBetween, u as cronMatches, p as cronNextFire, h as isKnownTimeZone, n as parseCron, o as zonedClock };

package/dist/actions/index.d.ts

@@ -1,4 +1,4 @@
-export { cronMatches, isKnownTimeZone, parseCron, zonedClock } from './cron';
+export { cronFiresBetween, cronMatches, cronNextFire, isKnownTimeZone, parseCron, zonedClock } from './cron';
 export { FAILURE_HANDLER_TASK } from './failureHandler';
 export { triggerAccess, triggerCacheMs, triggerHasStaleVerify, triggerInput, triggerVerify } from './triggerParams';
 export { actionName, actionTriggers, isActionEnabled } from './triggers';

package/dist/actions/index.mjs

@@ -1,7 +1,7 @@
-import { cronMatches as e, isKnownTimeZone as t, parseCron as n, zonedClock as r } from "./cron.mjs";
-import { FAILURE_HANDLER_TASK as i } from "./failureHandler.mjs";
-import { triggerAccess as a, triggerCacheMs as o, triggerHasStaleVerify as s, triggerInput as c, triggerVerify as l } from "./triggerParams.mjs";
-import { actionName as u, actionTriggers as d, isActionEnabled as f } from "./triggers.mjs";
-import { validateActionDocument as p } from "./validateDocument.mjs";
-import { SMTP_CREDENTIAL_KEYS as m, isSingleEmailAddress as h, readSmtpCredential as g } from "./smtp.mjs";
-export { i as FAILURE_HANDLER_TASK, m as SMTP_CREDENTIAL_KEYS, u as actionName, d as actionTriggers, e as cronMatches, f as isActionEnabled, t as isKnownTimeZone, h as isSingleEmailAddress, n as parseCron, g as readSmtpCredential, a as triggerAccess, o as triggerCacheMs, s as triggerHasStaleVerify, c as triggerInput, l as triggerVerify, p as validateActionDocument, r as zonedClock };
+import { cronFiresBetween as e, cronMatches as t, cronNextFire as n, isKnownTimeZone as r, parseCron as i, zonedClock as a } from "./cron.mjs";
+import { FAILURE_HANDLER_TASK as o } from "./failureHandler.mjs";
+import { triggerAccess as s, triggerCacheMs as c, triggerHasStaleVerify as l, triggerInput as u, triggerVerify as d } from "./triggerParams.mjs";
+import { actionName as f, actionTriggers as p, isActionEnabled as m } from "./triggers.mjs";
+import { validateActionDocument as h } from "./validateDocument.mjs";
+import { SMTP_CREDENTIAL_KEYS as g, isSingleEmailAddress as _, readSmtpCredential as v } from "./smtp.mjs";
+export { o as FAILURE_HANDLER_TASK, g as SMTP_CREDENTIAL_KEYS, f as actionName, p as actionTriggers, e as cronFiresBetween, t as cronMatches, n as cronNextFire, m as isActionEnabled, r as isKnownTimeZone, _ as isSingleEmailAddress, i as parseCron, v as readSmtpCredential, s as triggerAccess, c as triggerCacheMs, l as triggerHasStaleVerify, u as triggerInput, d as triggerVerify, h as validateActionDocument, a as zonedClock };

package/dist/actions/triggers.d.ts

@@ -25,5 +25,9 @@ export declare const isActionEnabled: (document: ActionDocument) => boolean;
  *
  * Falls back to whatever the document already carries, so a document written before this — or by a caller that
  * names it directly, like the authoring API — keeps the name it was given.
+ *
+ * A title that only repeats the trigger's kind is not a name: it is the default a node gets before anybody names
+ * it. Read as one, every page-rendered action in a workspace was called "render" and every clock "schedule" — a list
+ * of runs nobody could tell apart — while the document's own name sat unused beside it.
  */
 export declare const actionName: (document: ActionDocument) => string;

package/dist/actions/triggers.mjs

@@ -1,4 +1,7 @@
 //#region src/actions/triggers.ts
-var e = (e) => Object.values(e.nodes).filter((e) => e.type === "trigger"), t = (t) => e(t).some((e) => e.enabled), n = (t) => e(t).find((e) => e.title.trim() !== "")?.title.trim() ?? t.name;
+var e = (e) => Object.values(e.nodes).filter((e) => e.type === "trigger"), t = (t) => e(t).some((e) => e.enabled), n = (t) => e(t).find((e) => {
+	let t = e.title.trim();
+	return t !== "" && t !== e.action;
+})?.title.trim() ?? t.name;
 //#endregion
 export { n as actionName, e as actionTriggers, t as isActionEnabled };

package/dist/authoring/declare.d.ts

@@ -1,3 +1,4 @@
+import { InteractionCallback } from '../types/InteractionTypes';
 /**
  * How an element says what it can be authored with.
  *
@@ -29,6 +30,26 @@ export interface ElementDeclarationData {
      * reads it to resolve a binding that named the element alone.
      */
     sourceType?: string;
+    /**
+     * The triggers this type fires on top of the ones every element does (`onClick`, `onLoad`…), by action name.
+     *
+     * Declared here for the reason `sourceType` is: the component registers exactly these, and the authoring surface
+     * reads them to refuse a flow that starts on a trigger its element never fires — an `onSubmit` on the submit
+     * button rather than on the form is a flow that is written, saved and silently never runs.
+     */
+    triggers?: Record<string, InteractionCallback>;
+    /**
+     * The callbacks this type runs on itself on top of the ones every element does (`setState`, `toggleState`) —
+     * their static half. The component adds what only a mounted element has: the function, a title naming its label,
+     * options drawn from its children. Read by the authoring surface to refuse a step aimed at an element that does not
+     * answer to it — an `openModal` sent to a plain container is a button that does nothing.
+     */
+    callbacks?: Record<string, InteractionCallback>;
+    /**
+     * The type this one only works somewhere inside: it reads its state from that element's context, and anywhere
+     * else it throws on its first render. A dropdown's panel, a tab container's header and body.
+     */
+    ancestorType?: string;
     content?: {
         attributes?: Record<string, unknown>;
         definition?: {

package/dist/dataSource/getBindingsDetails.mjs

@@ -1,43 +1,44 @@
 import e from "./utility/index.mjs";
-import { camelCase as t, get as n, set as r } from "@plitzi/plitzi-ui/helpers/lodash";
-import { QueryBuilderEvaluator as i } from "@plitzi/plitzi-ui/QueryBuilder";
-import { produce as a } from "immer";
+import { checkboxParams as t } from "./utility/checkboxParams.mjs";
+import { camelCase as n, get as r, set as i } from "@plitzi/plitzi-ui/helpers/lodash";
+import { QueryBuilderEvaluator as a } from "@plitzi/plitzi-ui/QueryBuilder";
+import { produce as o } from "immer";
 //#region src/dataSource/getBindingsDetails.ts
-var o = (e, t, r, i, a) => {
+var s = (e, t, n, i, a) => {
 	let o = i === "initialState" ? `definition.${i}.${a}` : `${i}.${a}`;
 	return {
-		fromValue: t ? n(e, t, n(r, o)) : void 0,
-		toValue: n(r, o, t ? n(e, t) : void 0)
+		fromValue: t ? r(e, t, r(n, o)) : void 0,
+		toValue: r(n, o, t ? r(e, t) : void 0)
 	};
-}, s = (s, c, l = {}) => {
+}, c = (r, c, l = {}) => {
 	let { attributes: u, definition: d } = c, { bindings: f } = d;
 	return !f || typeof f == "object" && !Object.keys(f).length ? {
 		attributes: u,
 		style: {},
 		definition: d
-	} : a({
+	} : o({
 		attributes: u,
 		style: l,
 		definition: d
-	}, (a) => {
+	}, (o) => {
 		Object.keys(f).forEach((c) => {
 			f[c] && Array.isArray(f[c]) && f[c].length && f[c].forEach((l) => {
 				let { source: u, transformers: d, when: f, enabled: p = !0 } = l, { to: m } = l;
-				if (!m || f && !i(f, s, !1, !0) || !p) return;
-				c === "style" && (m = t(m));
-				let { fromValue: h, toValue: g } = o(s, u, a, c, m), _ = h;
-				d && Array.isArray(d) && d.length > 0 && d.forEach((t) => {
-					let { action: r, params: i, enabled: o = !0 } = t;
-					if (!o) return;
-					let c = n(e, `${r}.callback`);
-					typeof c == "function" && (_ = c(_, i, a, {
-						...s,
+				if (!m || f && !a(f, r, !1, !0) || !p) return;
+				c === "style" && (m = n(m));
+				let { fromValue: h, toValue: g } = s(r, u, o, c, m), _ = h;
+				d && Array.isArray(d) && d.length > 0 && d.forEach((n) => {
+					let { action: i, params: a, enabled: s = !0 } = n;
+					if (!s) return;
+					let c = e[i];
+					c && (_ = c.callback(_, t(c, a) ?? {}, o, {
+						...r,
 						sourceTo: g
 					}));
-				}), (typeof _ == "boolean" || typeof _ == "number" || _) && (c === "initialState" ? r(a, `definition.${c}.${m}`, _) : r(a, `${c}.${m}`, _));
+				}), (typeof _ == "boolean" || typeof _ == "number" || _) && (c === "initialState" ? i(o, `definition.${c}.${m}`, _) : i(o, `${c}.${m}`, _));
 			});
 		});
 	});
 };
 //#endregion
-export { s as default };
+export { c as default };

package/dist/dataSource/utility/checkboxParams.d.ts

@@ -0,0 +1,11 @@
+import { DataSourceUtility, DataSourceUtilityParamsValue } from '../../types';
+/**
+ * A checkbox param as the boolean it means.
+ *
+ * A document stores what an editor or an author wrote, and a checkbox arrives both ways: `true` from the builder,
+ * `'true'` or `'false'` from anything that writes params as text — an authored space, an export, an agent. A callback
+ * reading `if (asAge)` takes `'false'` for yes, so `dateConverter({ asAge: 'false' })` printed "3 days ago" and
+ * `isUnix: 'false'` parsed an ISO date as a number and gave the raw string back. Normalised once here, before any
+ * callback runs, every utility reads a checkbox the same way.
+ */
+export declare const checkboxParams: <TParams>(utility: Pick<DataSourceUtility<unknown, unknown, TParams>, "params">, params: DataSourceUtilityParamsValue<TParams> | undefined) => DataSourceUtilityParamsValue<TParams> | undefined;

package/dist/dataSource/utility/checkboxParams.mjs

@@ -0,0 +1,12 @@
+//#region src/dataSource/utility/checkboxParams.ts
+var e = (e, t) => {
+	if (!t) return t;
+	let n = t;
+	for (let [r, i] of Object.entries(e.params)) {
+		let e = t[r];
+		e !== "true" && e !== "false" || (typeof i.type == "function" ? i.type(t) : i.type) !== "checkbox" || (n === t && (n = { ...t }), n[r] = e === "true");
+	}
+	return n;
+};
+//#endregion
+export { e as checkboxParams };

package/dist/helpers/index.mjs

@@ -1,14 +1,15 @@
 import { filters as e } from "./twigWrapper/filters/filters.mjs";
 import { processTwig as t } from "./twigWrapper/processTwig/processTwig.mjs";
-import { hasValidToken as n } from "./twigWrapper/tokens/hasValidToken.mjs";
-import { templateRootNames as r } from "./twigWrapper/templateRoots.mjs";
-import i from "./fetchManifest.mjs";
-import a from "./generateFacade.mjs";
-import o from "./syntaxHighlight.mjs";
-import { formatDate as s, formatDateUTC as c, formatFromNow as l, formatUTCToLocal as u, getDurationMs as d, isDate as f, isValidFormat as p, parseDate as m, toUnixSeconds as h } from "./formatDate.mjs";
-import { isUserEdit as g } from "./reducerOrigin.mjs";
-import { evaluateRuleGroup as _ } from "./ruleEvaluator.mjs";
-import { ParamsFromURL as v, delay as y, emptyObject as b, getDisplayName as x, getKeyDecoded as S, getPathsFromObeject as C, hexToRGB as w, isInViewport as T, makeId as E } from "./utils.mjs";
-import { disableReactDevTools as D } from "./security.mjs";
-import { createStripTypenameLink as O, stripTypenameDeep as k } from "./stripTypename.mjs";
-export { v as ParamsFromURL, O as createStripTypenameLink, y as delay, D as disableReactDevTools, b as emptyObject, _ as evaluateRuleGroup, i as fetchManifest, e as filters, s as formatDate, c as formatDateUTC, l as formatFromNow, u as formatUTCToLocal, a as generateFacade, x as getDisplayName, d as getDurationMs, S as getKeyDecoded, C as getPathsFromObeject, n as hasValidToken, w as hexToRGB, f as isDate, T as isInViewport, g as isUserEdit, p as isValidFormat, E as makeId, m as parseDate, t as processTwig, k as stripTypenameDeep, o as syntaxHighlight, r as templateRootNames, h as toUnixSeconds };
+import { hasTemplateSyntax as n } from "./twigWrapper/tokens/hasTemplateSyntax.mjs";
+import { hasValidToken as r } from "./twigWrapper/tokens/hasValidToken.mjs";
+import { templateRootNames as i } from "./twigWrapper/templateRoots.mjs";
+import a from "./fetchManifest.mjs";
+import o from "./generateFacade.mjs";
+import s from "./syntaxHighlight.mjs";
+import { formatDate as c, formatDateUTC as l, formatFromNow as u, formatUTCToLocal as d, getDurationMs as f, isDate as p, isValidFormat as m, parseDate as h, toUnixSeconds as g } from "./formatDate.mjs";
+import { isUserEdit as _ } from "./reducerOrigin.mjs";
+import { evaluateRuleGroup as v } from "./ruleEvaluator.mjs";
+import { ParamsFromURL as y, delay as b, emptyObject as x, getDisplayName as S, getKeyDecoded as C, getPathsFromObeject as w, hexToRGB as T, isInViewport as E, makeId as D } from "./utils.mjs";
+import { disableReactDevTools as O } from "./security.mjs";
+import { createStripTypenameLink as k, stripTypenameDeep as A } from "./stripTypename.mjs";
+export { y as ParamsFromURL, k as createStripTypenameLink, b as delay, O as disableReactDevTools, x as emptyObject, v as evaluateRuleGroup, a as fetchManifest, e as filters, c as formatDate, l as formatDateUTC, u as formatFromNow, d as formatUTCToLocal, o as generateFacade, S as getDisplayName, f as getDurationMs, C as getKeyDecoded, w as getPathsFromObeject, n as hasTemplateSyntax, r as hasValidToken, T as hexToRGB, p as isDate, E as isInViewport, _ as isUserEdit, m as isValidFormat, D as makeId, h as parseDate, t as processTwig, A as stripTypenameDeep, s as syntaxHighlight, i as templateRootNames, g as toUnixSeconds };

package/dist/helpers/twigWrapper/Evaluator/Evaluator.mjs

@@ -1,14 +1,22 @@
 import { isTruthy as e, resolveCollection as t, resolveObjectEntries as n, valueIn as r } from "./helpers.mjs";
 import { ARROW_PARAMS as i, filters as a, isRawMarker as o, unwrapRaw as s } from "../filters/filters.mjs";
 //#region src/helpers/twigWrapper/Evaluator/Evaluator.ts
-var c = [], l = (e, t, n = !1) => {
-	let r = new u(t, n);
+var c = {
+	defined: (e) => e !== void 0,
+	null: (e) => e == null,
+	none: (e) => e == null,
+	empty: (e) => e == null || e === "" || e === !1 || Array.isArray(e) && e.length === 0 || typeof e == "object" && !Array.isArray(e) && Object.keys(e).length === 0,
+	iterable: (e) => Array.isArray(e) || typeof e == "object" && !!e,
+	even: (e) => typeof e == "number" && e % 2 == 0,
+	odd: (e) => typeof e == "number" && Math.abs(e % 2) === 1
+}, l = (e) => e.type === "path" || e.type === "filter" && l(e.subject), u = (e, t) => t == null || t === "" && l(e), d = [], f = (e, t, n = !1) => {
+	let r = new p(t, n);
 	return {
 		output: r.evalNodes(e),
 		variables: r.variables,
 		hasSet: r.hasSet
 	};
-}, u = class l {
+}, p = class l {
 	variables;
 	keepEmptyTokens;
 	breakFlag = !1;
@@ -39,7 +47,7 @@ var c = [], l = (e, t, n = !1) => {
 	}
 	evalVariable(e) {
 		let t = this.evalExpression(e.expression);
-		return this.keepEmptyTokens && (t == null || t === "") ? e.source : o(t) ? String(s(t)) : typeof t == "function" ? "" : t != null && typeof t != "object" ? String(t) : e.raw ? t == null ? "" : String(t) : typeof t == "object" && t ? JSON.stringify(t) : "";
+		return this.keepEmptyTokens && u(e.expression, t) ? e.source : o(t) ? String(s(t)) : typeof t == "function" ? "" : t != null && typeof t != "object" ? String(t) : e.raw ? t == null ? "" : String(t) : typeof t == "object" && t ? JSON.stringify(t) : "";
 	}
 	evalIf(t) {
 		if (e(this.evalExpression(t.condition))) return this.evalNodes(t.body);
@@ -94,7 +102,7 @@ var c = [], l = (e, t, n = !1) => {
 		let n = e;
 		for (let e of t) {
 			let t = a[e.name];
-			t !== void 0 && (n = t(n, e.args.length === 0 ? c : this.evalArgs(e.args)));
+			t !== void 0 && (n = t(n, e.args.length === 0 ? d : this.evalArgs(e.args)));
 		}
 		return n;
 	}
@@ -200,6 +208,13 @@ var c = [], l = (e, t, n = !1) => {
 		return a;
 	}
 	evalBinary(t, n, i) {
+		if ((t === "is" || t === "is not") && i.type === "path" && i.segments.length === 1) {
+			let e = c[i.segments[0]];
+			if (e) {
+				let r = e(this.evalExpression(n));
+				return t === "is" ? r : !r;
+			}
+		}
 		if (t === "or") return e(this.evalExpression(n)) || e(this.evalExpression(i));
 		if (t === "and") return e(this.evalExpression(n)) && e(this.evalExpression(i));
 		let a = this.evalExpression(n), o = this.evalExpression(i), s = typeof a == "number" && typeof o == "number";
@@ -224,4 +239,4 @@ var c = [], l = (e, t, n = !1) => {
 	}
 };
 //#endregion
-export { l as evaluate };
+export { f as evaluate };

package/dist/helpers/twigWrapper/Parser/ExpressionParser.mjs

@@ -163,7 +163,7 @@ var r = (e) => new a(e).parseTernary(), i = (e) => new a(e).parseApplyChain(), a
 			});
 			this.pos = t;
 			let r = this.parseTernary();
-			return this.skipWs(), this.peek() === e.RParen && this.pos++, this.maybeTrailingFilters(r);
+			return this.skipWs(), this.peek() === e.RParen && this.pos++, this.maybeTrailingFilters(this.parseAccessChain(r, null));
 		}
 		return n === e.SingleQuote || n === e.DoubleQuote ? this.maybeTrailingFilters({
 			type: "literal",

package/dist/helpers/twigWrapper/filters/filters.mjs

@@ -124,7 +124,12 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 		f.set(e, null);
 	}
 	return f.get(e) ?? null;
-}, m = (e, t) => {
+}, m = (e) => {
+	if (e instanceof Date) return e;
+	if (typeof e == "number") return new Date(e);
+	let t = String(e).trim();
+	return /^-?\d+$/.test(t) ? new Date(Number(t)) : new Date(t);
+}, h = (e, t) => {
 	if (!t) return {
 		year: e.getFullYear(),
 		month: e.getMonth() + 1,
@@ -146,7 +151,7 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 		seconds: Number(i("second")),
 		weekday: d.indexOf(i("weekday"))
 	};
-}, h = {
+}, g = {
 	raw: (e) => l(e),
 	to_json: (e) => typeof e == "object" && e ? JSON.stringify(e) : r(e),
 	json_encode: (e) => typeof e == "object" && e ? JSON.stringify(e) : r(e),
@@ -307,9 +312,9 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 	random: (e) => Array.isArray(e) ? e.length > 0 ? e[Math.floor(Math.random() * e.length)] : void 0 : typeof e == "string" ? e.length > 0 ? e[Math.floor(Math.random() * e.length)] : "" : typeof e == "number" ? Math.floor(Math.random() * e) : e,
 	date: (e, t) => {
 		if (t.length === 0) return e;
-		let n = r(t[0]), i = e instanceof Date ? e : new Date(String(e));
+		let n = r(t[0]), i = m(e);
 		if (Number.isNaN(i.getTime())) return "";
-		let a = m(i, t.length > 1 ? r(t[1]) : "");
+		let a = h(i, t.length > 1 ? r(t[1]) : "");
 		if (!a) return "";
 		let o = (e) => String(e).padStart(2, "0"), s = {
 			Y: String(a.year),
@@ -424,4 +429,4 @@ var e = Symbol("twigArrowParams"), t = (e) => e == null || e === "", n = (e, t)
 	}
 };
 //#endregion
-export { e as ARROW_PARAMS, s as RAW_MARKER, h as filters, c as isRawMarker, u as unwrapRaw, l as wrapRaw };
+export { e as ARROW_PARAMS, s as RAW_MARKER, g as filters, c as isRawMarker, u as unwrapRaw, l as wrapRaw };

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

@@ -1,4 +1,5 @@
 export { processTwig } from './processTwig';
+export { hasTemplateSyntax } from './tokens/hasTemplateSyntax';
 export { hasValidToken } from './tokens/hasValidToken';
 export { templateRootNames } from './templateRoots';
 export { filters } from './filters/filters';

package/dist/helpers/twigWrapper/index.mjs

@@ -1,5 +1,6 @@
 import { filters as e } from "./filters/filters.mjs";
 import { processTwig as t } from "./processTwig/processTwig.mjs";
-import { hasValidToken as n } from "./tokens/hasValidToken.mjs";
-import { templateRootNames as r } from "./templateRoots.mjs";
-export { e as filters, n as hasValidToken, t as processTwig, r as templateRootNames };
+import { hasTemplateSyntax as n } from "./tokens/hasTemplateSyntax.mjs";
+import { hasValidToken as r } from "./tokens/hasValidToken.mjs";
+import { templateRootNames as i } from "./templateRoots.mjs";
+export { e as filters, n as hasTemplateSyntax, r as hasValidToken, t as processTwig, i as templateRootNames };