@invinite-org/chartlang-language-service 1.4.4 → 1.4.5

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @invinite-org/chartlang-language-service
 
+## 1.4.5
+
+### Patch Changes
+
+- 08cba38: Add `time.*` calendar accessors (`time.year/month/dayofmonth/dayofweek/hour/
+minute/second/timestamp`), a `time.timeClose(t, tz?)` bar-close accessor
+  (Pine's `time_close()` = bar start + interval), a `session.isOpen(t, spec, tz?)`
+  helper, and an `input.session` kind. Calendar fields are derived from a `Time`
+  epoch via the host (authors stay sandboxed — `Date`/`Intl` remain banned). v1
+  is UTC + fixed-offset only; exchange-tz/DST is a scoped follow-up. The Pine
+  converter lowers `dayofweek` / `time()` / `time_close()` / `input.session`.
+- 1efb49c: Add `state.array<T>(capacity)` — a persistent, bounded FIFO collection. Push
+  many values across bars (`a.push(v)`) into a fixed-capacity ring and read
+  them back by element (`a.get(0)` = newest, `a.last()`, `a.size`,
+  `a.capacity`, `a.clear()`). Bounded literal capacity keeps it
+  serialization-clean. The Pine converter lowers a bounded numeric
+  `var array<…>` Camp B ring to it.
+
+  The compiler guards the capacity: it must be a compile-time numeric literal
+  (a `const` numeric binding is accepted) that is a positive integer within
+  `MAX_STATE_ARRAY_CAPACITY` (100_000). A non-literal capacity errors
+  `state-array-capacity-not-literal`; an out-of-range / non-integer literal
+  errors `state-array-capacity-exceeds-max`.
+
+- Updated dependencies [189493a]
+- Updated dependencies [8bc628e]
+- Updated dependencies [ab8b218]
+- Updated dependencies [8bc628e]
+- Updated dependencies [ab8b218]
+- Updated dependencies [189493a]
+- Updated dependencies [e620ba8]
+- Updated dependencies [08cba38]
+- Updated dependencies [1efb49c]
+- Updated dependencies [1efb49c]
+  - @invinite-org/chartlang-adapter-kit@1.6.0
+  - @invinite-org/chartlang-core@1.3.0
+  - @invinite-org/chartlang-compiler@1.4.0
+
 ## 1.4.4
 
 ### Patch Changes

package/dist/hoverRegistry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hoverRegistry.generated.d.ts","sourceRoot":"","sources":["../src/hoverRegistry.generated.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,QAAQ,CAAC;CACvB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AAEH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAwqPvE,CAAC"}
+{"version":3,"file":"hoverRegistry.generated.d.ts","sourceRoot":"","sources":["../src/hoverRegistry.generated.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,QAAQ,CAAC;CACvB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AAEH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAonQvE,CAAC"}

package/dist/hoverRegistry.generated.js

@@ -375,6 +375,40 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.1",
         "stability": "stable"
     },
+    "barcolor": {
+        "fqn": "barcolor",
+        "kind": "function",
+        "title": "barcolor(_color, _opts?)",
+        "summary": "Tint the candle / bar for the current bar — the Pine-ergonomic alias for\n`plot(NaN, { style: { kind: \"bar-color\", color } })`. Sugar over the\nexisting `bar-color` plot style.",
+        "paramTable": [
+            {
+                "name": "_color",
+                "type": "Color",
+                "doc": ""
+            },
+            {
+                "name": "_opts",
+                "type": "BarColorOpts",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "// Inside a compiled `compute`:\n//   barcolor(bar.close > bar.open ? \"#16a34a\" : \"#dc2626\");\nimport { barcolor } from \"@invinite-org/chartlang-core\";\ntry { barcolor(\"#a855f7\"); } catch {}"
+        ],
+        "since": "1.4",
+        "stability": "stable"
+    },
+    "BarColorOpts": {
+        "fqn": "BarColorOpts",
+        "kind": "type",
+        "title": "BarColorOpts",
+        "summary": "Styling options accepted by `barcolor(...)` — the Pine-ergonomic alias for\na `bar-color` candle/bar tint. The `bar-color` style carries no\ntransparency, so this bag only labels the slot.",
+        "examples": [
+            "const opts: BarColorOpts = { title: \"trend tint\" };\nvoid opts;"
+        ],
+        "since": "1.4",
+        "stability": "stable"
+    },
     "BarSeries": {
         "fqn": "BarSeries",
         "kind": "type",
@@ -474,6 +508,40 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.2",
         "stability": "stable"
     },
+    "bgcolor": {
+        "fqn": "bgcolor",
+        "kind": "function",
+        "title": "bgcolor(_color, _opts?)",
+        "summary": "Paint the pane background for the current bar — the Pine-ergonomic alias\nfor `plot(NaN, { style: { kind: \"bg-color\", color, transp } })`. Pass a\n`Color` (a CSS / hex string, or a per-bar color expression like\n`close > open ? \"#16a34a\" : \"#dc2626\"`). Sugar over the existing\n`bg-color` plot style — same wire emission, same capability gate.",
+        "paramTable": [
+            {
+                "name": "_color",
+                "type": "Color",
+                "doc": ""
+            },
+            {
+                "name": "_opts",
+                "type": "BgColorOpts",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "// Inside a compiled `compute`:\n//   bgcolor(bar.close > bar.open ? \"#16a34a\" : \"#dc2626\", { transp: 80 });\nimport { bgcolor } from \"@invinite-org/chartlang-core\";\ntry { bgcolor(\"#1d4ed8\"); } catch {}"
+        ],
+        "since": "1.4",
+        "stability": "stable"
+    },
+    "BgColorOpts": {
+        "fqn": "BgColorOpts",
+        "kind": "type",
+        "title": "BgColorOpts",
+        "summary": "/**\nStyling options accepted by `bgcolor(...)` — the Pine-ergonomic alias for\na `bg-color` pane-background band. `transp` is the 0–100 transparency\n(0 opaque … 100 fully transparent), mirroring  {@link PlotOptsStyle} 's\n`bg-color` arm. `title` labels the slot for host overrides.",
+        "examples": [
+            "const opts: BgColorOpts = { transp: 80, title: \"RSI heat\" };\nvoid opts;"
+        ],
+        "since": "1.4",
+        "stability": "stable"
+    },
     "BoolDescriptor": {
         "fqn": "BoolDescriptor",
         "kind": "type",
@@ -2673,6 +2741,29 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.4",
         "stability": "stable"
     },
+    "feedKey": {
+        "fqn": "feedKey",
+        "kind": "function",
+        "title": "feedKey(symbol, interval)",
+        "summary": "Build the composite secondary-feed key from a `(symbol, interval)` pair —\nthe **single** source of the stream-key format shared by the runtime's\nstream/cache maps and the host wire (`CandleEvent.streamKey`). Like a slot\nid, this string is load-bearing: producer (adapter/host) and consumer\n(runtime) must agree byte-for-byte, so never re-derive it inline.",
+        "paramTable": [
+            {
+                "name": "symbol",
+                "type": "string | undefined",
+                "doc": ""
+            },
+            {
+                "name": "interval",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "feedKey(undefined, \"1D\"); // \"1D\"  (chart symbol, back-compat)\nfeedKey(\"AMEX:SPY\", \"1D\"); // \"AMEX:SPY@1D\""
+        ],
+        "since": "1.3",
+        "stability": "stable"
+    },
     "FibChannelState": {
         "fqn": "FibChannelState",
         "kind": "type",
@@ -3410,6 +3501,29 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.4",
         "stability": "stable"
     },
+    "input.session": {
+        "fqn": "input.session",
+        "kind": "function",
+        "title": "input.session(defaultValue, opts?)",
+        "summary": "Build a session-window input descriptor (`\"HH:MM-HH:MM\"`). The value is\na free string in v1 (the grammar is parsed at runtime by\n`session.isOpen`), mirroring `input.string`.",
+        "paramTable": [
+            {
+                "name": "defaultValue",
+                "type": "string",
+                "doc": ""
+            },
+            {
+                "name": "opts",
+                "type": "{ readonly title?: string }",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const sess = input.session(\"0930-1600\", { title: \"Session\" });\nvoid sess;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
     "input.source": {
         "fqn": "input.source",
         "kind": "function",
@@ -3967,6 +4081,17 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.2",
         "stability": "stable"
     },
+    "MutableArraySlot": {
+        "fqn": "MutableArraySlot",
+        "kind": "type",
+        "title": "MutableArraySlot",
+        "summary": "/**\nScript-facing handle on a persistent, bounded **FIFO collection** —\nPine's `var array<…>` with capacity eviction. Unlike  {@link MutableSlot} * (one value's history) or a `Series` (bar-indexed history), this is a\n*collection** you push many values into: `push` appends (evicting the\noldest once `capacity` is reached), `get(n)` reads the `n`-th element from\nthe newest (`n = 0`), `last()` is the newest, `size` is the current filled\ncount, `capacity` is the fixed bound, and `clear()` empties it.",
+        "examples": [
+            "function rollingMean(a: MutableArraySlot<number>, x: number): number {\na.push(x);\nlet sum = 0;\nfor (let i = 0; i < a.size; i++) sum += a.get(i);\nreturn sum / a.size;\n}"
+        ],
+        "since": "1.3",
+        "stability": "stable"
+    },
     "MutableSlot": {
         "fqn": "MutableSlot",
         "kind": "type",
@@ -4572,11 +4697,23 @@ export const HOVER_REGISTRY = Object.freeze({
         ],
         "examples": [
             "// weekly EMA(20) — computed over weekly bars, drawn on the chart\nconst trend = request.security({ interval: \"1W\" }, (bar) => ta.ema(bar.close, 20));\nplot(trend, { title: \"Weekly EMA(20)\" });",
-            "// data form — aligned weekly close\nconst weekly = request.security({ interval: \"1W\" });\nplot(weekly.close, { title: \"Weekly close\" });"
+            "// data form — aligned weekly close\nconst weekly = request.security({ interval: \"1W\" });\nplot(weekly.close, { title: \"Weekly close\" });",
+            "// different symbol — a ratio against another instrument (needs multiSymbol)\nconst spy = request.security({ symbol: \"AMEX:SPY\", interval: \"1D\" });\nconst qqq = request.security({ symbol: \"NASDAQ:QQQ\", interval: \"1D\" });\nplot(spy.close.current / qqq.close.current, { title: \"SPY/QQQ\" });"
         ],
         "since": "0.4",
         "stability": "stable"
     },
+    "RequestedFeed": {
+        "fqn": "RequestedFeed",
+        "kind": "type",
+        "title": "RequestedFeed",
+        "summary": "One requested secondary feed — a `(symbol, interval)` pair the script's\n`request.security` calls ask for. `symbol` omitted ⇒ the chart's own\nsymbol (the higher-timeframe-only case). The compiler emits one entry per\ndistinct** feed; the runtime creates one secondary `StreamState` per\nentry, keyed by the shared `feedKey(symbol, interval)` composite.",
+        "examples": [
+            "const f: RequestedFeed = { symbol: \"AMEX:SPY\", interval: \"1D\" };\nvoid f;"
+        ],
+        "since": "1.3",
+        "stability": "stable"
+    },
     "RequestLowerTfOpts": {
         "fqn": "RequestLowerTfOpts",
         "kind": "type",
@@ -4605,7 +4742,8 @@ export const HOVER_REGISTRY = Object.freeze({
         "title": "RequestSecurityOpts",
         "summary": "/**\nArgument to  {@link request.security} . The `interval` must be a string\nliteral or an `input.enum` value; the compiler's literal-only pass rejects\ndynamic expressions with `request-security-interval-not-literal`.",
         "examples": [
-            "const opts: RequestSecurityOpts = { interval: \"1D\" };\nvoid opts;"
+            "const opts: RequestSecurityOpts = { interval: \"1D\" };\nvoid opts;",
+            "// read a different instrument (requires Capabilities.multiSymbol)\nconst spy: RequestSecurityOpts = { symbol: \"AMEX:SPY\", interval: \"1D\" };\nvoid spy;"
         ],
         "since": "0.4",
         "stability": "stable"
@@ -4814,7 +4952,7 @@ export const HOVER_REGISTRY = Object.freeze({
         "title": "SecurityExpressionDescriptor",
         "summary": "One higher-timeframe expression unit in `ScriptManifest.securityExpressions`.\nThe compiler emits one entry per `request.security({ interval }, (bar) => …)`\ncallsite so the runtime knows which `slotId` is an HTF expression, on which\n`interval` to clock it, and the callback's single parameter name. The\ncallback body stays inline in the compiled module — this descriptor is only\nthe registry pointing at it.",
         "examples": [
-            "const unit: SecurityExpressionDescriptor = {\nslotId: \"trend.ts:8:21#0\",\ninterval: \"1W\",\nparamName: \"bar\",\n};\nvoid unit;"
+            "// symbol omitted ⇒ the chart's own symbol (the HTF-only back-compat case)\nconst unit: SecurityExpressionDescriptor = {\nslotId: \"trend.ts:8:21#0\",\ninterval: \"1W\",\nparamName: \"bar\",\n};\nvoid unit;"
         ],
         "since": "0.7",
         "stability": "stable"
@@ -4841,6 +4979,34 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.6",
         "stability": "stable"
     },
+    "session.isOpen": {
+        "fqn": "session.isOpen",
+        "kind": "function",
+        "title": "session.isOpen(_t, _spec, _tz?)",
+        "summary": "`true` when `t` falls inside the daily session window `spec`. `spec` is\nan `\"HH:MM-HH:MM\"` (or `\"HHMM-HHMM\"`) intraday window, e.g.\n`\"0930-1600\"`. The window is interpreted in `tz` (default\n`syminfo.timezone`, fallback `\"UTC\"`).",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_spec",
+                "type": "string",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof session.isOpen = session.isOpen;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
     "SessionBounds": {
         "fqn": "SessionBounds",
         "kind": "type",
@@ -4852,6 +5018,28 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.6",
         "stability": "stable"
     },
+    "SessionDescriptor": {
+        "fqn": "SessionDescriptor",
+        "kind": "type",
+        "title": "SessionDescriptor",
+        "summary": "Descriptor for `input.session(...)`. The value is an `\"HH:MM-HH:MM\"`\n(or `\"HHMM-HHMM\"`) session-window spec consumed by `session.isOpen`.\nStructurally a constrained string; v1 does not validate the grammar at\ncompile time.",
+        "examples": [
+            "const d: SessionDescriptor = { kind: \"session\", defaultValue: \"0930-1600\" };\nvoid d;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "SessionNamespace": {
+        "fqn": "SessionNamespace",
+        "kind": "type",
+        "title": "SessionNamespace",
+        "summary": "Static type of the `session` namespace. Runtime implementations satisfy this\nshape structurally when installed on `ComputeContext.session`.",
+        "examples": [
+            "const ns: SessionNamespace = session;\nvoid ns;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
     "SessionType": {
         "fqn": "SessionType",
         "kind": "type",
@@ -4984,6 +5172,24 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.4",
         "stability": "stable"
     },
+    "state.array": {
+        "fqn": "state.array",
+        "kind": "function",
+        "title": "state.array(_capacity)",
+        "summary": "/**\nAllocate or read a persistent **bounded collection** slot — a\nfixed-capacity FIFO ring you push values into across bars. `a.push(v)`\nappends (evicting the oldest once full); `a.get(n)` reads the `n`-th\nelement from the newest; `a.last()` is the newest; `a.size` is the\nfilled count; `a.capacity` is the bound; `a.clear()` empties it.\n`capacity` must be a compile-time numeric literal (the slot is bounded\nso it serializes). Unlike  {@link state} .series (one value's bar-indexed\nhistory), this is a collection of many pushed values. v1 supports\n`number` element type.",
+        "paramTable": [
+            {
+                "name": "_capacity",
+                "type": "number",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof state.array = state.array;\nvoid fn;"
+        ],
+        "since": "1.3",
+        "stability": "stable"
+    },
     "state.bool": {
         "fqn": "state.bool",
         "kind": "function",
@@ -5100,7 +5306,7 @@ export const HOVER_REGISTRY = Object.freeze({
         "fqn": "STATEFUL_PRIMITIVES_BY_NAME",
         "kind": "property",
         "title": "STATEFUL_PRIMITIVES_BY_NAME",
-        "summary": "/**\nName → entry index of  {@link STATEFUL_PRIMITIVES} . The compiler's\n`callsiteIdInjection` and `statefulCallInLoop` passes consult this map\nby callee name once per call site — O(1) lookup instead of an O(n) scan\nover the 176-entry set on every visited call. The map is derived from\nthe same canonical entry list as  {@link STATEFUL_PRIMITIVES} so adding\na primitive to the set adds it here automatically.",
+        "summary": "/**\nName → entry index of  {@link STATEFUL_PRIMITIVES} . The compiler's\n`callsiteIdInjection` and `statefulCallInLoop` passes consult this map\nby callee name once per call site — O(1) lookup instead of an O(n) scan\nover the 179-entry set on every visited call. The map is derived from\nthe same canonical entry list as  {@link STATEFUL_PRIMITIVES} so adding\na primitive to the set adds it here automatically.",
         "examples": [
             "import { STATEFUL_PRIMITIVES_BY_NAME } from \"@invinite-org/chartlang-core\";\nconst entry = STATEFUL_PRIMITIVES_BY_NAME.get(\"ta.ema\");\n// entry is { name: \"ta.ema\", slot: true } | undefined"
         ],
@@ -7347,6 +7553,17 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.3",
         "stability": "stable"
     },
+    "time": {
+        "fqn": "time",
+        "kind": "namespace",
+        "title": "time",
+        "summary": "Calendar accessors over a `Time` epoch (UTC ms since epoch). Each accessor\nis a pure function of an explicit `Time` plus an optional IANA timezone\nstring; the default `tz` is the active mount's `syminfo.timezone`, falling\nback to `\"UTC\"` when that is empty. Authors never touch `Date`/`Intl` (both\nare banned on the script path) — the runtime owns the epoch math.",
+        "examples": [
+            "const ns: typeof time = time;\nvoid ns;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
     "Time": {
         "fqn": "Time",
         "kind": "type",
@@ -7358,6 +7575,238 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.1",
         "stability": "stable"
     },
+    "time.dayofmonth": {
+        "fqn": "time.dayofmonth",
+        "kind": "function",
+        "title": "time.dayofmonth(_t, _tz?)",
+        "summary": "Day of the month of `t`, `1..31`.",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.dayofmonth = time.dayofmonth;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.dayofweek": {
+        "fqn": "time.dayofweek",
+        "kind": "function",
+        "title": "time.dayofweek(_t, _tz?)",
+        "summary": "Day of the week of `t`, following Pine's convention `1=Sunday .. 7=Saturday`\n(note: NOT the ISO `1=Monday` convention).",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.dayofweek = time.dayofweek;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.hour": {
+        "fqn": "time.hour",
+        "kind": "function",
+        "title": "time.hour(_t, _tz?)",
+        "summary": "Hour-of-day of `t`, `0..23`.",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.hour = time.hour;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.minute": {
+        "fqn": "time.minute",
+        "kind": "function",
+        "title": "time.minute(_t, _tz?)",
+        "summary": "Minute-of-hour of `t`, `0..59`.",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.minute = time.minute;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.month": {
+        "fqn": "time.month",
+        "kind": "function",
+        "title": "time.month(_t, _tz?)",
+        "summary": "Calendar month of `t`, `1..12`.",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.month = time.month;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.second": {
+        "fqn": "time.second",
+        "kind": "function",
+        "title": "time.second(_t, _tz?)",
+        "summary": "Second-of-minute of `t`, `0..59`.",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.second = time.second;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.timeClose": {
+        "fqn": "time.timeClose",
+        "kind": "function",
+        "title": "time.timeClose(_t, _tz?)",
+        "summary": "Close timestamp of the bar that starts at `t` — Pine's no-arg\n`time_close()`. Equals `t + interval`, where the interval is the active\nbar's `timeframe.inSeconds` the runtime reads internally (so this mirrors\nPine's \"current bar's interval\" without an explicit interval argument).\n`tz` is accepted for surface symmetry with the other `time.*` accessors.",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.timeClose = time.timeClose;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.timestamp": {
+        "fqn": "time.timestamp",
+        "kind": "function",
+        "title": "time.timestamp(_year, _month, _day, _hour?, _minute?, _second?, _tz?)",
+        "summary": "Build a `Time` (UTC ms epoch) from calendar fields. `month` is `1..12`\nand `day` is `1..31`; `hour`/`minute`/`second` default to `0`. The\nfields are interpreted in `tz` (default `syminfo.timezone`, fallback\n`\"UTC\"`).",
+        "paramTable": [
+            {
+                "name": "_year",
+                "type": "number",
+                "doc": ""
+            },
+            {
+                "name": "_month",
+                "type": "number",
+                "doc": ""
+            },
+            {
+                "name": "_day",
+                "type": "number",
+                "doc": ""
+            },
+            {
+                "name": "_hour",
+                "type": "number",
+                "doc": ""
+            },
+            {
+                "name": "_minute",
+                "type": "number",
+                "doc": ""
+            },
+            {
+                "name": "_second",
+                "type": "number",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.timestamp = time.timestamp;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
+    "time.year": {
+        "fqn": "time.year",
+        "kind": "function",
+        "title": "time.year(_t, _tz?)",
+        "summary": "Calendar year of `t` (e.g. `2024`).",
+        "paramTable": [
+            {
+                "name": "_t",
+                "type": "Time",
+                "doc": ""
+            },
+            {
+                "name": "_tz",
+                "type": "string",
+                "doc": ""
+            }
+        ],
+        "examples": [
+            "const fn: typeof time.year = time.year;\nvoid fn;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
     "TimeCyclesState": {
         "fqn": "TimeCyclesState",
         "kind": "type",
@@ -7402,6 +7851,17 @@ export const HOVER_REGISTRY = Object.freeze({
         "since": "0.4",
         "stability": "stable"
     },
+    "TimeNamespace": {
+        "fqn": "TimeNamespace",
+        "kind": "type",
+        "title": "TimeNamespace",
+        "summary": "Static type of the `time` namespace. Runtime implementations satisfy this\nshape structurally when installed on `ComputeContext.time`.",
+        "examples": [
+            "const ns: TimeNamespace = time;\nvoid ns;"
+        ],
+        "since": "1.5",
+        "stability": "stable"
+    },
     "TrendAngleState": {
         "fqn": "TrendAngleState",
         "kind": "type",