{
  "name": "slex-capabilities-catalog",
  "packageName": "slexkit",
  "version": "0.4.0",
  "schemaVersion": "2026-06",
  "protocolVersion": "0.1",
  "expressionContext": [
    {
      "name": "g",
      "scope": "always",
      "summary": "Reactive state proxy."
    },
    {
      "name": "std",
      "scope": "always",
      "summary": "Pure deterministic SlexKit standard library."
    },
    {
      "name": "api",
      "scope": "host-injected",
      "summary": "Host or secure runtime capability object."
    },
    {
      "name": "$event",
      "scope": "event handlers",
      "summary": "Event payload for on* handlers."
    },
    {
      "name": "$item",
      "scope": "$for",
      "summary": "Current array item."
    },
    {
      "name": "$index",
      "scope": "$for",
      "summary": "Current item index."
    },
    {
      "name": "$key",
      "scope": "$for",
      "summary": "Current item key."
    }
  ],
  "stdlib": [
    {
      "name": "math",
      "summary": "Small numeric helpers for common interactive calculations.",
      "functions": [
        {
          "name": "std.math.clamp",
          "signature": "clamp(value, min, max)",
          "summary": "Clamp a number into a range.",
          "pure": true,
          "example": "std.math.clamp(g.score, 0, 100)"
        },
        {
          "name": "std.math.round",
          "signature": "round(value, digits = 0)",
          "summary": "Round with a fixed number of decimal digits.",
          "pure": true,
          "example": "std.math.round(g.latency, 1)"
        },
        {
          "name": "std.math.safeDivide",
          "signature": "safeDivide(numerator, denominator, fallback = 0)",
          "summary": "Divide with a fallback for zero or invalid denominators.",
          "pure": true,
          "example": "std.math.safeDivide(g.used, g.total, 0)"
        },
        {
          "name": "std.math.percent",
          "signature": "percent(part, total, digits = 1)",
          "summary": "Return part / total as a percentage number.",
          "pure": true,
          "example": "std.math.percent(g.done, g.total, 1)"
        },
        {
          "name": "std.math.lerp",
          "signature": "lerp(start, end, t)",
          "summary": "Linear interpolation.",
          "pure": true,
          "example": "std.math.lerp(0, 100, g.progress)"
        }
      ]
    },
    {
      "name": "stats",
      "summary": "Finite-number aggregations for arrays.",
      "functions": [
        {
          "name": "std.stats.sum",
          "signature": "sum(values)",
          "summary": "Sum finite numeric values. Empty arrays return 0.",
          "pure": true,
          "example": "std.stats.sum(g.samples)"
        },
        {
          "name": "std.stats.mean",
          "signature": "mean(values)",
          "summary": "Average finite numeric values. Empty arrays return NaN.",
          "pure": true,
          "example": "std.stats.mean(g.samples)"
        },
        {
          "name": "std.stats.min",
          "signature": "min(values)",
          "summary": "Minimum finite numeric value. Empty arrays return NaN.",
          "pure": true,
          "example": "std.stats.min(g.samples)"
        },
        {
          "name": "std.stats.max",
          "signature": "max(values)",
          "summary": "Maximum finite numeric value. Empty arrays return NaN.",
          "pure": true,
          "example": "std.stats.max(g.samples)"
        },
        {
          "name": "std.stats.median",
          "signature": "median(values)",
          "summary": "Median finite numeric value. Empty arrays return NaN.",
          "pure": true,
          "example": "std.stats.median(g.samples)"
        }
      ]
    },
    {
      "name": "format",
      "summary": "Deterministic display formatting with en-US defaults.",
      "functions": [
        {
          "name": "std.format.fixed",
          "signature": "fixed(value, digits = 2)",
          "summary": "Format a number with fixed decimal places.",
          "pure": true,
          "example": "std.format.fixed(g.voltage, 3)"
        },
        {
          "name": "std.format.number",
          "signature": "number(value, digits = 0, locale = 'en-US')",
          "summary": "Locale number formatting.",
          "pure": true,
          "example": "std.format.number(g.requests)"
        },
        {
          "name": "std.format.compact",
          "signature": "compact(value, digits = 1, locale = 'en-US')",
          "summary": "Compact number formatting.",
          "pure": true,
          "example": "std.format.compact(g.users)"
        },
        {
          "name": "std.format.percent",
          "signature": "percent(ratio, digits = 1)",
          "summary": "Format a ratio as a percentage string.",
          "pure": true,
          "example": "std.format.percent(g.done / g.total, 1)"
        },
        {
          "name": "std.format.currency",
          "signature": "currency(value, currency = 'USD', locale = 'en-US')",
          "summary": "Format a currency value.",
          "pure": true,
          "example": "std.format.currency(g.revenue, 'USD')"
        }
      ]
    },
    {
      "name": "units",
      "summary": "Small unit display helpers for common dashboards.",
      "functions": [
        {
          "name": "std.units.withUnit",
          "signature": "withUnit(value, unit, digits = 2)",
          "summary": "Format a value with a unit suffix.",
          "pure": true,
          "example": "std.units.withUnit(g.power, 'W', 1)"
        },
        {
          "name": "std.units.bytes",
          "signature": "bytes(value, digits = 1)",
          "summary": "Format bytes as B, KB, MB, GB, TB, or PB.",
          "pure": true,
          "example": "std.units.bytes(g.payloadBytes)"
        },
        {
          "name": "std.units.duration",
          "signature": "duration(ms, digits = 1)",
          "summary": "Format milliseconds as ms, s, min, or h.",
          "pure": true,
          "example": "std.units.duration(g.elapsedMs)"
        },
        {
          "name": "std.units.si",
          "signature": "si(value, unit = '', digits = 2)",
          "summary": "Format with SI prefixes.",
          "pure": true,
          "example": "std.units.si(g.frequency, 'Hz', 2)"
        }
      ]
    }
  ],
  "stdlibFunctionNames": [
    "std.math.clamp",
    "std.math.round",
    "std.math.safeDivide",
    "std.math.percent",
    "std.math.lerp",
    "std.stats.sum",
    "std.stats.mean",
    "std.stats.min",
    "std.stats.max",
    "std.stats.median",
    "std.format.fixed",
    "std.format.number",
    "std.format.compact",
    "std.format.percent",
    "std.format.currency",
    "std.units.withUnit",
    "std.units.bytes",
    "std.units.duration",
    "std.units.si"
  ],
  "apiCapabilities": [
    {
      "name": "api.get",
      "policy": "network",
      "signature": "get(url, options)",
      "summary": "Policy-gated GET request.",
      "example": "await api.get('https://api.example.com/status')",
      "secureDefault": "denied",
      "forbidden": [
        "fetch(url)",
        "XMLHttpRequest",
        "WebSocket"
      ]
    },
    {
      "name": "api.post",
      "policy": "network",
      "signature": "post(url, body, options)",
      "summary": "Policy-gated POST request.",
      "example": "await api.post('https://api.example.com/items', { ok: true })",
      "secureDefault": "denied",
      "forbidden": [
        "fetch(url)",
        "XMLHttpRequest",
        "WebSocket"
      ]
    },
    {
      "name": "api.fetch",
      "policy": "network",
      "signature": "fetch(url, options)",
      "summary": "Policy-gated GET or POST request.",
      "example": "await api.fetch(url, { method: 'GET' })",
      "secureDefault": "denied",
      "forbidden": [
        "fetch(url)",
        "XMLHttpRequest",
        "WebSocket"
      ]
    },
    {
      "name": "api.setTimeout",
      "policy": "timer",
      "signature": "setTimeout(fn, ms)",
      "summary": "Policy-gated timeout.",
      "example": "api.setTimeout(function () { g.ready = true; }, 500)",
      "secureDefault": "denied",
      "forbidden": [
        "setTimeout(fn, ms)"
      ]
    },
    {
      "name": "api.clearTimeout",
      "policy": "timer",
      "signature": "clearTimeout(id)",
      "summary": "Clear a policy-gated timeout.",
      "example": "api.clearTimeout(g.timeoutId)",
      "secureDefault": "denied"
    },
    {
      "name": "api.setInterval",
      "policy": "timer",
      "signature": "setInterval(fn, ms)",
      "summary": "Policy-gated interval.",
      "example": "api.setInterval(function () { g.ticks += 1; }, 1000)",
      "secureDefault": "denied",
      "forbidden": [
        "setInterval(fn, ms)"
      ]
    },
    {
      "name": "api.clearInterval",
      "policy": "timer",
      "signature": "clearInterval(id)",
      "summary": "Clear a policy-gated interval.",
      "example": "api.clearInterval(g.intervalId)",
      "secureDefault": "denied"
    },
    {
      "name": "api.raf",
      "policy": "animation",
      "signature": "raf(fn)",
      "summary": "Policy-gated animation frame.",
      "example": "api.raf(function (time) { g.time = time; })",
      "secureDefault": "denied",
      "forbidden": [
        "requestAnimationFrame(fn)"
      ]
    },
    {
      "name": "api.cancelRaf",
      "policy": "animation",
      "signature": "cancelRaf(id)",
      "summary": "Cancel a policy-gated animation frame.",
      "example": "api.cancelRaf(g.rafId)",
      "secureDefault": "denied"
    },
    {
      "name": "api.createCanvas",
      "policy": "canvas",
      "signature": "createCanvas(width, height)",
      "summary": "Create a policy-counted canvas.",
      "example": "var canvas = api.createCanvas(320, 180)",
      "secureDefault": "denied"
    },
    {
      "name": "api.getCanvasContext",
      "policy": "canvas",
      "signature": "getCanvasContext(canvas, contextId, options)",
      "summary": "Get a policy-checked canvas context.",
      "example": "var ctx = api.getCanvasContext(canvas, '2d')",
      "secureDefault": "denied"
    },
    {
      "name": "api.onDispose",
      "policy": "lifecycle",
      "signature": "onDispose(fn)",
      "summary": "Register runtime cleanup.",
      "example": "api.onDispose(function () { g.closed = true; })",
      "secureDefault": "available"
    },
    {
      "name": "api.now",
      "policy": "lifecycle",
      "signature": "now()",
      "summary": "Runtime clock.",
      "example": "api.now()",
      "secureDefault": "available"
    },
    {
      "name": "api.isTimeoutError",
      "policy": "diagnostics",
      "signature": "isTimeoutError(error)",
      "summary": "Check timeout errors.",
      "example": "api.isTimeoutError(error)",
      "secureDefault": "available"
    },
    {
      "name": "api.isNetworkError",
      "policy": "diagnostics",
      "signature": "isNetworkError(error)",
      "summary": "Check network errors.",
      "example": "api.isNetworkError(error)",
      "secureDefault": "available"
    },
    {
      "name": "api.isPolicyError",
      "policy": "diagnostics",
      "signature": "isPolicyError(error)",
      "summary": "Check policy errors.",
      "example": "api.isPolicyError(error)",
      "secureDefault": "available"
    },
    {
      "name": "api.errorMessage",
      "policy": "diagnostics",
      "signature": "errorMessage(error)",
      "summary": "Extract a displayable error message.",
      "example": "api.errorMessage(error)",
      "secureDefault": "available"
    }
  ],
  "apiCapabilityNames": [
    "api.get",
    "api.post",
    "api.fetch",
    "api.setTimeout",
    "api.clearTimeout",
    "api.setInterval",
    "api.clearInterval",
    "api.raf",
    "api.cancelRaf",
    "api.createCanvas",
    "api.getCanvasContext",
    "api.onDispose",
    "api.now",
    "api.isTimeoutError",
    "api.isNetworkError",
    "api.isPolicyError",
    "api.errorMessage"
  ],
  "secureNativeCapabilitiesDenied": [
    "fetch",
    "XMLHttpRequest",
    "WebSocket",
    "setTimeout",
    "setInterval",
    "requestAnimationFrame"
  ]
}