@invinite-org/chartlang-core 1.0.1

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,84 @@
+import type { JsonValue } from "../types.js";
+/**
+ * Runtime log severity emitted by `runtime.log.*`.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     const level: LogLevel = "info";
+ *     void level;
+ */
+export type LogLevel = "info" | "warn" | "error";
+/**
+ * Per-step log message. Pine's `runtime.log.*` analogue. Capability-
+ * gated by `Capabilities.logs`; silent no-op when false.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.info(`ema=${ema.current}`, { ema: ema.current });
+ */
+declare function _logInfo(_message: string, _meta?: Readonly<Record<string, JsonValue>>): void;
+/**
+ * Per-step warning log message. Capability-gated by `Capabilities.logs`.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.warn("warmup incomplete");
+ */
+declare function _logWarn(_message: string, _meta?: Readonly<Record<string, JsonValue>>): void;
+/**
+ * Per-step error log message. Capability-gated by `Capabilities.logs`.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.error("unexpected branch", { branch: "fallback" });
+ */
+declare function _logError(_message: string, _meta?: Readonly<Record<string, JsonValue>>): void;
+/**
+ * Halt the current bar's compute. Emits a fatal `RuntimeDiagnostic`
+ * with code `runtime-error-thrown`. The script stays mounted; the
+ * next bar runs normally. Use for invariant violations the script
+ * cannot continue past.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // if (inputs.length < 1) runtime.error("length must be >= 1");
+ */
+declare function _error(_message: string): never;
+/**
+ * Pine-style runtime utilities exposed to script `compute` callbacks.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.info("close", { value: bar.close });
+ */
+export declare const runtime: Readonly<{
+    log: Readonly<{
+        info: typeof _logInfo;
+        warn: typeof _logWarn;
+        error: typeof _logError;
+    }>;
+    error: typeof _error;
+}>;
+/**
+ * Script-facing runtime namespace type.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     const ns: RuntimeNamespace = runtime;
+ *     void ns;
+ */
+export type RuntimeNamespace = typeof runtime;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEjD;;;;;;;;;GASG;AACH,iBAAS,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAErF;AAED;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAErF;AAED;;;;;;;;GAQG;AACH,iBAAS,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAEtF;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAEvC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO;;;;;;;EAOlB,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,OAAO,CAAC"}

package/dist/runtime/runtime.js

@@ -0,0 +1,72 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+/**
+ * Per-step log message. Pine's `runtime.log.*` analogue. Capability-
+ * gated by `Capabilities.logs`; silent no-op when false.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.info(`ema=${ema.current}`, { ema: ema.current });
+ */
+function _logInfo(_message, _meta) {
+    throw new Error("runtime.log.info called outside compiled runtime");
+}
+/**
+ * Per-step warning log message. Capability-gated by `Capabilities.logs`.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.warn("warmup incomplete");
+ */
+function _logWarn(_message, _meta) {
+    throw new Error("runtime.log.warn called outside compiled runtime");
+}
+/**
+ * Per-step error log message. Capability-gated by `Capabilities.logs`.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.error("unexpected branch", { branch: "fallback" });
+ */
+function _logError(_message, _meta) {
+    throw new Error("runtime.log.error called outside compiled runtime");
+}
+/**
+ * Halt the current bar's compute. Emits a fatal `RuntimeDiagnostic`
+ * with code `runtime-error-thrown`. The script stays mounted; the
+ * next bar runs normally. Use for invariant violations the script
+ * cannot continue past.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // if (inputs.length < 1) runtime.error("length must be >= 1");
+ */
+function _error(_message) {
+    throw new Error("runtime.error called outside compiled runtime");
+}
+/**
+ * Pine-style runtime utilities exposed to script `compute` callbacks.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     // Inside compute:
+ *     // runtime.log.info("close", { value: bar.close });
+ */
+export const runtime = Object.freeze({
+    log: Object.freeze({
+        info: _logInfo,
+        warn: _logWarn,
+        error: _logError,
+    }),
+    error: _error,
+});
+//# sourceMappingURL=runtime.js.map

package/dist/runtime/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/runtime/runtime.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAe/D;;;;;;;;;GASG;AACH,SAAS,QAAQ,CAAC,QAAgB,EAAE,KAA2C;IAC3E,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,QAAQ,CAAC,QAAgB,EAAE,KAA2C;IAC3E,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,QAAgB,EAAE,KAA2C;IAC5E,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,MAAM,CAAC,QAAgB;IAC5B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC;QACf,IAAI,EAAE,QAAQ;QACd,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,SAAS;KACnB,CAAC;IACF,KAAK,EAAE,MAAM;CAChB,CAAC,CAAC"}

package/dist/state/index.d.ts

@@ -0,0 +1,5 @@
+export { state } from "./state.js";
+export type { StateNamespace } from "./state.js";
+export type { MutableSlot } from "./mutableSlot.js";
+export type { StateSnapshot, StateStoreKey, StreamSnapshot } from "./snapshot.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/dist/state/index.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+export { state } from "./state.js";
+//# sourceMappingURL=index.js.map

package/dist/state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAE/D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dist/state/mutableSlot.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Script-facing handle on a persistent cross-bar slot, Pine's `var` /
+ * `varip` equivalent. Reads return the active step value; writes follow
+ * the runtime's committed/tentative slot semantics.
+ *
+ * Intentionally minimal: no `.history()`, no `.previous()`, no indexing.
+ * Scripts that need the previous bar's value store it in a second slot or
+ * use `ta.*` series-indexing primitives.
+ *
+ * @since 0.4
+ * @stable
+ * @example
+ *     const slot: MutableSlot<number> = {
+ *         get value() {
+ *             return 0;
+ *         },
+ *         set value(_next: number) {},
+ *     };
+ *     slot.value = 1;
+ */
+export type MutableSlot<T> = {
+    get value(): T;
+    set value(v: T);
+};
+//# sourceMappingURL=mutableSlot.d.ts.map

package/dist/state/mutableSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutableSlot.d.ts","sourceRoot":"","sources":["../../src/state/mutableSlot.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IACzB,IAAI,KAAK,IAAI,CAAC,CAAC;IACf,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE;CACnB,CAAC"}

package/dist/state/mutableSlot.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+export {};
+//# sourceMappingURL=mutableSlot.js.map

package/dist/state/mutableSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutableSlot.js","sourceRoot":"","sources":["../../src/state/mutableSlot.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D"}

package/dist/state/snapshot.d.ts

@@ -0,0 +1,108 @@
+import type { JsonValue } from "../types.js";
+/**
+ * Per-stream snapshot captured during state persistence.
+ *
+ * Carries everything needed to rehydrate a ring buffer for one timeframe,
+ * whether that stream is the main interval or a higher-timeframe secondary
+ * stream (PLAN.md §6.1, §6.9).
+ *
+ * `buffers` is keyed by the canonical OHLCV field names; each value is a
+ * JSON-clean array of `number | null`, where `null` preserves NaN holes
+ * through `JSON.stringify`. `headIndex` and `filled` mirror the ring-buffer's
+ * internal state at snapshot time.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     const s: StreamSnapshot = {
+ *         interval: "1D",
+ *         headIndex: 4999,
+ *         filled: 5000,
+ *         buffers: { time: [], open: [], high: [], low: [], close: [], volume: [] },
+ *     };
+ *     void s;
+ */
+export type StreamSnapshot = Readonly<{
+    interval: string;
+    headIndex: number;
+    filled: number;
+    buffers: Readonly<{
+        time: ReadonlyArray<number | null>;
+        open: ReadonlyArray<number | null>;
+        high: ReadonlyArray<number | null>;
+        low: ReadonlyArray<number | null>;
+        close: ReadonlyArray<number | null>;
+        volume: ReadonlyArray<number | null>;
+    }>;
+}>;
+/**
+ * Canonical persistent-store snapshot.
+ *
+ * Written on `dispose()` and on every `kind: "close"` event when stale for
+ * at least 60 seconds (PLAN.md §6.9). `slots` carries every stateful
+ * primitive's per-callsite payload keyed by the compiler-injected slot id
+ * (PLAN.md §5.5). Each value is `JsonValue`; primitive authors with non-JSON
+ * internal state register serialisation hooks in the runtime layer.
+ *
+ * `snapshotVersion: 1` is the only currently-supported wire version. A future
+ * schema change must bump this literal so the runtime can drop snapshots with
+ * mismatched versions on load.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     const s: StateSnapshot = {
+ *         lastBarTime: 1_700_000_000_000,
+ *         streams: {},
+ *         slots: {},
+ *         savedAt: 1_700_000_060_000,
+ *         snapshotVersion: 1,
+ *     };
+ *     void s;
+ */
+export type StateSnapshot = Readonly<{
+    lastBarTime: number;
+    streams: Readonly<Record<string, StreamSnapshot>>;
+    slots: Readonly<Record<string, JsonValue>>;
+    savedAt: number;
+    snapshotVersion: 1;
+}>;
+/**
+ * Canonical persistent-store identity tuple.
+ *
+ * Every field contributes to the cache key; any change invalidates the
+ * snapshot (PLAN.md §6.9). Stores treat this tuple opaquely as a string key;
+ * the typical implementation is `JSON.stringify(key)` with sorted fields.
+ *
+ * - `scriptHash` is the SHA-256 digest of the compiled `moduleSource`.
+ * - `compilerVersion` is the package version of `@invinite-org/chartlang-compiler`.
+ * - `apiVersion` is the script header pin, currently `1`.
+ * - `capabilitiesHash` is the SHA-256 digest of normalised adapter capabilities.
+ * - `symbol` is the adapter's loaded ticker.
+ * - `mainInterval` is the primary stream interval.
+ * - `requestedIntervals` is the frozen array of secondary stream intervals.
+ *
+ * @since 0.5
+ * @stable
+ * @example
+ *     const k: StateStoreKey = {
+ *         scriptHash: "abc",
+ *         compilerVersion: "0.5.0",
+ *         apiVersion: 1,
+ *         capabilitiesHash: "def",
+ *         symbol: "BTCUSD",
+ *         mainInterval: "1m",
+ *         requestedIntervals: [],
+ *     };
+ *     void k;
+ */
+export type StateStoreKey = Readonly<{
+    scriptHash: string;
+    compilerVersion: string;
+    apiVersion: 1;
+    capabilitiesHash: string;
+    symbol: string;
+    mainInterval: string;
+    requestedIntervals: ReadonlyArray<string>;
+}>;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/state/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/state/snapshot.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC;QACd,IAAI,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QACnC,IAAI,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QACnC,IAAI,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QACnC,GAAG,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QAClC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QACpC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;KACxC,CAAC,CAAC;CACN,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;IAClD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,CAAC,CAAC;CACtB,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,CAAC,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C,CAAC,CAAC"}

package/dist/state/snapshot.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+export {};
+//# sourceMappingURL=snapshot.js.map

package/dist/state/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../src/state/snapshot.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D"}

package/dist/state/state.d.ts

@@ -0,0 +1,86 @@
+import type { MutableSlot } from "./mutableSlot.js";
+/**
+ * Persistent state slots, Pine `var` semantics. Writes during a tick are
+ * tentative and discarded if a later tick replaces the head bar; on bar
+ * close the tentative value commits. Reads return the active tentative
+ * value for the current step.
+ *
+ * The runtime replaces this compile-time callable hole with a slot-aware
+ * namespace through `ComputeContext.state`.
+ *
+ * @since 0.4
+ * @stable
+ * @example
+ *     const ns: typeof state = state;
+ *     void ns;
+ */
+export declare const state: Readonly<{
+    /**
+     * Allocate or read a persistent number slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.float = state.float;
+     *     void fn;
+     */
+    float(_init: number): MutableSlot<number>;
+    /**
+     * Allocate or read a persistent integer slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.int = state.int;
+     *     void fn;
+     */
+    int(_init: number): MutableSlot<number>;
+    /**
+     * Allocate or read a persistent boolean slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.bool = state.bool;
+     *     void fn;
+     */
+    bool(_init: boolean): MutableSlot<boolean>;
+    /**
+     * Allocate or read a persistent string slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.string = state.string;
+     *     void fn;
+     */
+    string(_init: string): MutableSlot<string>;
+    /**
+     * Tick-persistent state slots, Pine `varip` semantics. Writes commit
+     * immediately, even during a tick.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.tick.float = state.tick.float;
+     *     void fn;
+     */
+    tick: Readonly<{
+        float(_init: number): MutableSlot<number>;
+        int(_init: number): MutableSlot<number>;
+        bool(_init: boolean): MutableSlot<boolean>;
+        string(_init: string): MutableSlot<string>;
+    }>;
+}>;
+/**
+ * Static type of the `state` namespace. Runtime implementations satisfy
+ * this shape structurally when they are installed on `ComputeContext.state`.
+ *
+ * @since 0.4
+ * @stable
+ * @example
+ *     const ns: StateNamespace = state;
+ *     void ns;
+ */
+export type StateNamespace = typeof state;
+//# sourceMappingURL=state.d.ts.map

package/dist/state/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state/state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAMpD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK;IACd;;;;;;;;OAQG;iBACU,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAIzC;;;;;;;;OAQG;eACQ,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAIvC;;;;;;;;OAQG;gBACS,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;IAI1C;;;;;;;;OAQG;kBACW,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAI1C;;;;;;;;;OASG;;qBAEc,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;mBAG9B,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;oBAG3B,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;sBAG5B,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;;EAIhD,CAAC;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,KAAK,CAAC"}

package/dist/state/state.js

@@ -0,0 +1,95 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+const sentinel = (name) => {
+    throw new Error(`${name} called outside an active script step`);
+};
+/**
+ * Persistent state slots, Pine `var` semantics. Writes during a tick are
+ * tentative and discarded if a later tick replaces the head bar; on bar
+ * close the tentative value commits. Reads return the active tentative
+ * value for the current step.
+ *
+ * The runtime replaces this compile-time callable hole with a slot-aware
+ * namespace through `ComputeContext.state`.
+ *
+ * @since 0.4
+ * @stable
+ * @example
+ *     const ns: typeof state = state;
+ *     void ns;
+ */
+export const state = Object.freeze({
+    /**
+     * Allocate or read a persistent number slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.float = state.float;
+     *     void fn;
+     */
+    float(_init) {
+        return sentinel("state.float");
+    },
+    /**
+     * Allocate or read a persistent integer slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.int = state.int;
+     *     void fn;
+     */
+    int(_init) {
+        return sentinel("state.int");
+    },
+    /**
+     * Allocate or read a persistent boolean slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.bool = state.bool;
+     *     void fn;
+     */
+    bool(_init) {
+        return sentinel("state.bool");
+    },
+    /**
+     * Allocate or read a persistent string slot.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.string = state.string;
+     *     void fn;
+     */
+    string(_init) {
+        return sentinel("state.string");
+    },
+    /**
+     * Tick-persistent state slots, Pine `varip` semantics. Writes commit
+     * immediately, even during a tick.
+     *
+     * @since 0.4
+     * @stable
+     * @example
+     *     const fn: typeof state.tick.float = state.tick.float;
+     *     void fn;
+     */
+    tick: Object.freeze({
+        float(_init) {
+            return sentinel("state.tick.float");
+        },
+        int(_init) {
+            return sentinel("state.tick.int");
+        },
+        bool(_init) {
+            return sentinel("state.tick.bool");
+        },
+        string(_init) {
+            return sentinel("state.tick.string");
+        },
+    }),
+});
+//# sourceMappingURL=state.js.map

package/dist/state/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../src/state/state.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAI/D,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAS,EAAE;IACrC,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,uCAAuC,CAAC,CAAC;AACpE,CAAC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IAC/B;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAa;QACf,OAAO,QAAQ,CAAC,aAAa,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAa;QACb,OAAO,QAAQ,CAAC,WAAW,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;OAQG;IACH,IAAI,CAAC,KAAc;QACf,OAAO,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAa;QAChB,OAAO,QAAQ,CAAC,cAAc,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC;QAChB,KAAK,CAAC,KAAa;YACf,OAAO,QAAQ,CAAC,kBAAkB,CAAC,CAAC;QACxC,CAAC;QACD,GAAG,CAAC,KAAa;YACb,OAAO,QAAQ,CAAC,gBAAgB,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,KAAc;YACf,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC;QACvC,CAAC;QACD,MAAM,CAAC,KAAa;YAChB,OAAO,QAAQ,CAAC,mBAAmB,CAAC,CAAC;QACzC,CAAC;KACJ,CAAC;CACL,CAAC,CAAC"}

package/dist/statefulPrimitives.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Per-entry shape of {@link STATEFUL_PRIMITIVES}. `name` is the
+ * fully-qualified call (`ta.ema`, `plot`, `hline`, `alert`); `slot`
+ * is `true` for every primitive whose call site needs a compiler-
+ * injected slot id, `false` for the stateless helpers that ride along
+ * in the set for in-loop diagnostics (currently only `ta.nz`).
+ *
+ * @since 0.1
+ * @stable
+ * @example
+ *     const entry: StatefulPrimitiveEntry = { name: "ta.nz", slot: false };
+ */
+export type StatefulPrimitiveEntry = Readonly<{
+    name: string;
+    slot: boolean;
+}>;
+/**
+ * Frozen set of every fully-qualified call name the compiler tracks for
+ * static-analysis (`stateful-call-inside-loop`) and slot-id injection
+ * (PLAN.md §5.5). Each entry carries a `slot` flag: `slot: true`
+ * primitives allocate per-callsite hidden state and get a string-literal
+ * slot id injected as their first argument; `slot: false` primitives are
+ * pure helpers that ride along in the set because Pine still forbids
+ * them inside loops (e.g. `ta.nz`).
+ *
+ * Phase 1 shipped 12 `slot: true` entries. Phase 2 widens the shape to
+ * `{ name, slot }` so `ta.nz` (the only stateless Phase-2 cross-functional
+ * primitive) can opt out of slot-id injection without losing the
+ * in-loop diagnostic. Subsequent Phase-2 batch tasks (Tasks 6–28) each
+ * append `slot: true` entries; Phase 3 appends 61 `draw.<camelKind>`
+ * entries (all `slot: true`), and Phase 4 appends 8 `state.*` /
+ * `state.tick.*` entries plus request primitives. Phase 5 appends alert-condition signalling plus runtime
+ * logging/error as stateless loop-diagnostic entries plus `draw.table`
+ * as a slot-backed viewport drawing.
+ *
+ * Locked at `apiVersion: 1` (172 entries). Adding, removing, or renaming
+ * an entry is a language change and requires `apiVersion: 2` — see
+ * `docs/spec/versioning.md`.
+ *
+ * @since 0.1
+ * @stable
+ * @example
+ *     import { STATEFUL_PRIMITIVES } from "@invinite-org/chartlang-core";
+ *     for (const entry of STATEFUL_PRIMITIVES) {
+ *         if (entry.name === "ta.ema" && entry.slot) {
+ *             // compiler injects an id here
+ *         }
+ *     }
+ */
+export declare const STATEFUL_PRIMITIVES: ReadonlySet<StatefulPrimitiveEntry>;
+/**
+ * Name → entry index of {@link STATEFUL_PRIMITIVES}. The compiler's
+ * `callsiteIdInjection` and `statefulCallInLoop` passes consult this map
+ * by callee name once per call site — O(1) lookup instead of an O(n) scan
+ * over the 172-entry set on every visited call. The map is derived from
+ * the same canonical entry list as {@link STATEFUL_PRIMITIVES} so adding
+ * a primitive to the set adds it here automatically.
+ *
+ * Locked at `apiVersion: 1` (172 entries). Adding, removing, or renaming
+ * an entry is a language change and requires `apiVersion: 2` — see
+ * `docs/spec/versioning.md`.
+ *
+ * @since 0.2
+ * @stable
+ * @example
+ *     import { STATEFUL_PRIMITIVES_BY_NAME } from "@invinite-org/chartlang-core";
+ *     const entry = STATEFUL_PRIMITIVES_BY_NAME.get("ta.ema");
+ *     // entry is { name: "ta.ema", slot: true } | undefined
+ */
+export declare const STATEFUL_PRIMITIVES_BY_NAME: ReadonlyMap<string, StatefulPrimitiveEntry>;
+//# sourceMappingURL=statefulPrimitives.d.ts.map

package/dist/statefulPrimitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statefulPrimitives.d.ts","sourceRoot":"","sources":["../src/statefulPrimitives.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAoL/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,sBAAsB,CAEnE,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAGnB,CAAC"}