@driftengine/ai 3.61.0

package/dist/session/usage.d.ts

@@ -0,0 +1,43 @@
+import type { AiEvent } from '../provider/types.ts';
+/**
+ * What an agent has spent.
+ *
+ * Mutated in place. A session charges per event, and allocating a usage object per
+ * event would put an allocation on the path a streaming response takes hundreds of
+ * times per request.
+ */
+export interface AiUsage {
+    inputTokens: number;
+    outputTokens: number;
+    requests: number;
+    /**
+     * Requests aborted because a higher-priority observation arrived.
+     *
+     * The token price of responsiveness, and the number a consumer tunes its priority
+     * thresholds against. Separate from `abortedRequests` because disposal and hot
+     * reload also abort, and no threshold a consumer can set changes those.
+     */
+    preemptedRequests: number;
+    abortedRequests: number;
+    costMicros: number;
+    latencyMsP90: number;
+}
+export declare function createUsage(): AiUsage;
+/** Tokens only. Who aborted, and why, is something the session knows and an event does not. */
+export declare function chargeUsage(usage: AiUsage, event: AiEvent): void;
+/**
+ * Record an abort, whatever caused it.
+ *
+ * Counted where the session aborts rather than where the `done` event arrives. Reading
+ * it off the event double-counts every abort the session also has a reason for, and an
+ * aborted request produces a `done` *and* a decision — one abort, two places that
+ * could increment.
+ */
+export declare function noteAbort(usage: AiUsage): void;
+/**
+ * Record that the abort being taken is a preemption.
+ *
+ * Only the narrow counter. `noteAbort` moves the broad one, so a preemption increments
+ * both by going through both — and neither function has to know what the other did.
+ */
+export declare function notePreemption(usage: AiUsage): void;

package/dist/session/usage.js

@@ -0,0 +1,38 @@
+export function createUsage() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        requests: 0,
+        preemptedRequests: 0,
+        abortedRequests: 0,
+        costMicros: 0,
+        latencyMsP90: 0,
+    };
+}
+/** Tokens only. Who aborted, and why, is something the session knows and an event does not. */
+export function chargeUsage(usage, event) {
+    if (event.kind !== 'usage')
+        return;
+    usage.inputTokens += event.inputTokens;
+    usage.outputTokens += event.outputTokens;
+}
+/**
+ * Record an abort, whatever caused it.
+ *
+ * Counted where the session aborts rather than where the `done` event arrives. Reading
+ * it off the event double-counts every abort the session also has a reason for, and an
+ * aborted request produces a `done` *and* a decision — one abort, two places that
+ * could increment.
+ */
+export function noteAbort(usage) {
+    usage.abortedRequests++;
+}
+/**
+ * Record that the abort being taken is a preemption.
+ *
+ * Only the narrow counter. `noteAbort` moves the broad one, so a preemption increments
+ * both by going through both — and neither function has to know what the other did.
+ */
+export function notePreemption(usage) {
+    usage.preemptedRequests++;
+}

package/dist/testing/deterministic.d.ts

@@ -0,0 +1,65 @@
+import type { AiEvent, AiProvider, AiProviderCapabilities, AiSession, AiSessionOptions } from '../provider/types.ts';
+/**
+ * A provider that answers after a stated number of ticks, or never.
+ *
+ * **This is not a mock capability provider.** R1 withdrew mocks standing in for engine
+ * capabilities that did not exist, on the reasoning that a mock is a second
+ * implementation of a contract with no first implementation to check it against. This
+ * stands in for a *provider* — a thing that is genuinely remote, genuinely slow and
+ * genuinely variable — and it exists so that timing can be asserted rather than
+ * observed.
+ *
+ * **Nothing here runs on a real timer.** A response is due at an absolute tick, and a
+ * tick only happens when a caller says so. Every timing property Track O claims is
+ * measured against this, and on a real clock each of those measurements would be a
+ * race that passes on a fast machine.
+ *
+ * *What it costs:* a test must remember to call `advance`, and one that forgets sees
+ * an agent that never gets an answer. *What would make it wrong:* if a provider adapter
+ * ever needed wall-clock behaviour to be exercised — a retry backoff, say — this could
+ * not exercise it, and that adapter would need its own harness rather than a change here.
+ */
+export interface DeterministicScript {
+    /** Ticks between the request and its first event. `'never'` answers nothing, ever. */
+    readonly latencyTicks: number | 'never';
+    readonly events: readonly AiEvent[];
+}
+export declare class DeterministicProvider implements AiProvider {
+    readonly id = "deterministic";
+    readonly capabilities: AiProviderCapabilities;
+    private readonly pending;
+    private pendingCount;
+    private readonly script;
+    private latencyOverride;
+    private now;
+    private requests;
+    private aborted;
+    private live;
+    private peak;
+    constructor(script: DeterministicScript | ((requestIndex: number) => DeterministicScript));
+    get requestCount(): number;
+    get abortedCount(): number;
+    /** A high-water mark, never a current count. */
+    get peakConcurrency(): number;
+    /** Applies to requests made after this call, never to one already in flight. */
+    setLatencyTicks(ticks: number | 'never'): void;
+    /** Drives the fake clock. Nothing resolves without it. */
+    advance(tick: number): void;
+    createSession(_options: AiSessionOptions): AiSession;
+    /**
+     * Registered eagerly, before the generator's body runs.
+     *
+     * An async generator does not execute until its first `next()`, so building the
+     * entry inside `drain` would leave `peakConcurrency` reading zero for a request that
+     * had been made — the exact number the one-in-flight tests are asserting against.
+     *
+     * It is released when the request *settles*, not when the generator is drained. A
+     * request that has been answered or aborted is no longer outstanding whether or not
+     * its consumer has read it yet, and several fixed steps can run in one frame with no
+     * microtask between them — which made an aborted request go on counting.
+     */
+    private begin;
+    private settleAborted;
+    private drain;
+    private forget;
+}

package/dist/testing/deterministic.js

@@ -0,0 +1,150 @@
+const CAPABILITIES = {
+    text: true,
+    streamingText: true,
+    structuredOutput: true,
+    toolCalling: true,
+    realtimeAudio: false,
+    imageInput: false,
+    local: true,
+};
+export class DeterministicProvider {
+    id = 'deterministic';
+    capabilities = CAPABILITIES;
+    /*
+     * Reused with a count rather than emptied. `array.length = 0` makes V8 re-grow the
+     * backing store, which is a per-iteration allocation in loops this provider is
+     * deliberately driven through ten thousand times.
+     */
+    pending = [];
+    pendingCount = 0;
+    script;
+    latencyOverride = null;
+    now = 0;
+    requests = 0;
+    aborted = 0;
+    live = 0;
+    peak = 0;
+    constructor(script) {
+        this.script = typeof script === 'function' ? script : () => script;
+    }
+    get requestCount() {
+        return this.requests;
+    }
+    get abortedCount() {
+        return this.aborted;
+    }
+    /** A high-water mark, never a current count. */
+    get peakConcurrency() {
+        return this.peak;
+    }
+    /** Applies to requests made after this call, never to one already in flight. */
+    setLatencyTicks(ticks) {
+        this.latencyOverride = ticks;
+    }
+    /** Drives the fake clock. Nothing resolves without it. */
+    advance(tick) {
+        this.now = tick;
+        for (let i = 0; i < this.pendingCount; i++) {
+            const entry = this.pending[i];
+            if (entry === undefined || entry.settled)
+                continue;
+            if (entry.dueTick > tick)
+                continue;
+            entry.settled = true;
+            entry.outcome = 'due';
+            this.live--;
+            entry.wake?.();
+        }
+    }
+    createSession(_options) {
+        const owned = [];
+        return {
+            run: (request) => {
+                const entry = this.begin(request);
+                owned.push(entry);
+                return this.drain(entry);
+            },
+            abort: (reason) => {
+                for (const entry of owned)
+                    this.settleAborted(entry, reason ?? 'aborted');
+            },
+        };
+    }
+    /**
+     * Registered eagerly, before the generator's body runs.
+     *
+     * An async generator does not execute until its first `next()`, so building the
+     * entry inside `drain` would leave `peakConcurrency` reading zero for a request that
+     * had been made — the exact number the one-in-flight tests are asserting against.
+     *
+     * It is released when the request *settles*, not when the generator is drained. A
+     * request that has been answered or aborted is no longer outstanding whether or not
+     * its consumer has read it yet, and several fixed steps can run in one frame with no
+     * microtask between them — which made an aborted request go on counting.
+     */
+    begin(request) {
+        const script = this.script(this.requests);
+        this.requests++;
+        const latency = this.latencyOverride ?? script.latencyTicks;
+        const entry = {
+            dueTick: latency === 'never' ? Number.POSITIVE_INFINITY : this.now + latency,
+            events: script.events,
+            settled: false,
+            outcome: null,
+            message: '',
+            wake: null,
+        };
+        if (this.pendingCount < this.pending.length)
+            this.pending[this.pendingCount] = entry;
+        else
+            this.pending.push(entry);
+        this.pendingCount++;
+        this.live++;
+        if (this.live > this.peak)
+            this.peak = this.live;
+        if (request.signal.aborted)
+            this.settleAborted(entry, 'signal');
+        else
+            request.signal.addEventListener('abort', () => this.settleAborted(entry, 'signal'));
+        return entry;
+    }
+    settleAborted(entry, message) {
+        if (entry.settled)
+            return;
+        entry.settled = true;
+        entry.outcome = 'aborted';
+        entry.message = message;
+        this.aborted++;
+        this.live--;
+        entry.wake?.();
+    }
+    async *drain(entry) {
+        try {
+            if (!entry.settled) {
+                await new Promise((resolve) => {
+                    entry.wake = resolve;
+                });
+            }
+            if (entry.outcome === 'aborted') {
+                yield { kind: 'done', reason: 'aborted', message: entry.message };
+                return;
+            }
+            for (const event of entry.events)
+                yield event;
+        }
+        finally {
+            this.forget(entry);
+        }
+    }
+    forget(entry) {
+        for (let i = 0; i < this.pendingCount; i++) {
+            if (this.pending[i] !== entry)
+                continue;
+            const last = this.pending[this.pendingCount - 1];
+            if (last !== undefined)
+                this.pending[i] = last;
+            this.pendingCount--;
+            return;
+        }
+    }
+}

package/dist/tools/policy.d.ts

@@ -0,0 +1,47 @@
+import type { Budget } from '../budget/budget.ts';
+import type { ToolRegistry } from './registry.ts';
+export interface ExecutionPolicy {
+    /** Tool ids this agent may call at all. Absent means every registered tool. */
+    readonly allow?: readonly string[];
+    /** Calls per rate class, per second. */
+    readonly rateLimits?: Readonly<Record<string, number>>;
+    /** Tools a human has to say yes to. Refused here rather than queued. */
+    readonly requireApproval?: readonly string[];
+}
+export type Admission = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/**
+ * Rate state, owned by whoever owns the agent.
+ *
+ * **Not module-level.** A shared map keyed by class name would make two unrelated
+ * agents share one limit, so a busy one would silence a quiet one — and worse, a test
+ * would carry state into the next test. The session owns one of these; the limit is
+ * per agent, which is the only scope a consumer can reason about.
+ *
+ * Timestamps live in a reused array with a count, because `array.length = 0` re-grows
+ * V8's backing store and this is touched on every accepted call.
+ */
+export declare class RateWindows {
+    private readonly byClass;
+    /** Records the call and reports whether it fits. */
+    admit(rateClass: string, limit: number, nowMs: number): boolean;
+    clear(): void;
+}
+/**
+ * Whether a proposed tool call may be accepted.
+ *
+ * **The order is fixed and the first failure wins.** A call that is both unknown and
+ * over budget always reports that it is unknown, because a consumer chasing a message
+ * that changes between runs finds nothing wrong with either check. Order: exists,
+ * permitted, needs approval, arguments valid, within rate, within budget — cheapest
+ * and most specific first, so the message names the thing a reader can act on.
+ *
+ * This is the *acceptance* check. It does not run the tool's own `admits` guard: that
+ * runs at the tick boundary where the call is applied, because a snapshot is never
+ * authority and a buffered intent widens the gap between the two moments.
+ */
+export declare function admitToolCall<W>(registry: ToolRegistry<W>, policy: ExecutionPolicy, budget: Budget, toolId: string, args: unknown, nowMs: number, rates?: RateWindows): Admission;

package/dist/tools/policy.js

@@ -0,0 +1,84 @@
+import { validateArgs } from './validate.js';
+const OK = { ok: true };
+/**
+ * Rate state, owned by whoever owns the agent.
+ *
+ * **Not module-level.** A shared map keyed by class name would make two unrelated
+ * agents share one limit, so a busy one would silence a quiet one — and worse, a test
+ * would carry state into the next test. The session owns one of these; the limit is
+ * per agent, which is the only scope a consumer can reason about.
+ *
+ * Timestamps live in a reused array with a count, because `array.length = 0` re-grows
+ * V8's backing store and this is touched on every accepted call.
+ */
+export class RateWindows {
+    byClass = new Map();
+    /** Records the call and reports whether it fits. */
+    admit(rateClass, limit, nowMs) {
+        let window = this.byClass.get(rateClass);
+        if (window === undefined) {
+            window = { at: [], count: 0 };
+            this.byClass.set(rateClass, window);
+        }
+        let kept = 0;
+        for (let i = 0; i < window.count; i++) {
+            const stamp = window.at[i];
+            if (stamp !== undefined && nowMs - stamp < 1000)
+                window.at[kept++] = stamp;
+        }
+        window.count = kept;
+        if (window.count >= limit)
+            return false;
+        if (window.count < window.at.length)
+            window.at[window.count] = nowMs;
+        else
+            window.at.push(nowMs);
+        window.count++;
+        return true;
+    }
+    clear() {
+        this.byClass.clear();
+    }
+}
+/**
+ * Whether a proposed tool call may be accepted.
+ *
+ * **The order is fixed and the first failure wins.** A call that is both unknown and
+ * over budget always reports that it is unknown, because a consumer chasing a message
+ * that changes between runs finds nothing wrong with either check. Order: exists,
+ * permitted, needs approval, arguments valid, within rate, within budget — cheapest
+ * and most specific first, so the message names the thing a reader can act on.
+ *
+ * This is the *acceptance* check. It does not run the tool's own `admits` guard: that
+ * runs at the tick boundary where the call is applied, because a snapshot is never
+ * authority and a buffered intent widens the gap between the two moments.
+ */
+export function admitToolCall(registry, policy, budget, toolId, args, nowMs, rates = new RateWindows()) {
+    const tool = registry.get(toolId);
+    if (tool === undefined) {
+        return { ok: false, reason: `unknown tool "${toolId}" — it is not registered` };
+    }
+    if (policy.allow !== undefined && !policy.allow.includes(toolId)) {
+        return { ok: false, reason: `tool "${toolId}" is not permitted by this agent's policy` };
+    }
+    if (policy.requireApproval?.includes(toolId) === true) {
+        return { ok: false, reason: `tool "${toolId}" requires approval, which was not given` };
+    }
+    const validation = validateArgs(tool.schema, args);
+    if (!validation.ok) {
+        return { ok: false, reason: `${validation.path}: ${validation.reason}` };
+    }
+    const rateClass = tool.rateClass;
+    const limit = rateClass === undefined ? undefined : policy.rateLimits?.[rateClass];
+    if (rateClass !== undefined && limit !== undefined) {
+        if (!rates.admit(rateClass, limit, nowMs)) {
+            return {
+                ok: false,
+                reason: `rate class "${rateClass}" is over its limit of ${limit} per second`,
+            };
+        }
+    }
+    if (budget.exhausted)
+        return { ok: false, reason: budget.reason };
+    return OK;
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Tools an agent may call, and the guards that decide whether a proposal is still true.
+ *
+ * A tool schema is generated from the same contracts the language type-checks against,
+ * so it cannot drift from the implementation. That is what makes this different from
+ * writing a prompt that describes some functions.
+ */
+/**
+ * What a model may be asked to produce.
+ *
+ * Schema-expressible types only. Anything a schema cannot describe cannot be asked
+ * for, validated, or recorded in a trace, and a tool taking one would be a tool whose
+ * arguments are checked by hope.
+ */
+export type ToolSchema = {
+    readonly kind: 'string';
+} | {
+    readonly kind: 'number';
+} | {
+    readonly kind: 'boolean';
+} | {
+    readonly kind: 'enum';
+    readonly values: readonly string[];
+} | {
+    readonly kind: 'array';
+    readonly of: ToolSchema;
+} | {
+    readonly kind: 'object';
+    readonly fields: Readonly<Record<string, ToolSchema>>;
+};
+/**
+ * `W` is the consumer's world view, and this package never constrains it.
+ *
+ * An engine package that knew what a world contained would be an engine package that
+ * knew what game it was in. A guard asking `world.exists(id)` is the consumer's
+ * sentence, written against the consumer's world.
+ */
+export interface ToolDefinition<A, R, W> {
+    /** Stable and versioned — `inspect@1`. Never renumbered once shipped. */
+    readonly id: string;
+    readonly description: string;
+    readonly schema: ToolSchema;
+    readonly rateClass?: string;
+    readonly idempotent?: boolean;
+    /**
+     * Whether this call is still true of the world.
+     *
+     * Declared once, at registration, by the tool. The model never writes one: a
+     * model-authored precondition on a model-authored action is the model marking its
+     * own homework.
+     */
+    admits(args: A, world: W): boolean;
+    execute(args: A, world: W): R;
+}
+export declare class ToolRegistry<W> {
+    private readonly byId;
+    private readonly order;
+    register<A, R>(tool: ToolDefinition<A, R, W>): void;
+    /** Registration order, so a prompt's tool list is stable and a trace stays comparable. */
+    ids(): readonly string[];
+    get(id: string): ToolDefinition<never, never, W> | undefined;
+    /**
+     * Whether every tool an intent names still admits its arguments.
+     *
+     * A plain loop rather than a `map` and an `every`: this runs at the moment a
+     * buffered intent drains, which is inside a fixed step.
+     */
+    admits(toolIds: readonly string[], args: readonly unknown[], world: W): boolean;
+}

package/dist/tools/registry.js

@@ -0,0 +1,75 @@
+/**
+ * Tools an agent may call, and the guards that decide whether a proposal is still true.
+ *
+ * A tool schema is generated from the same contracts the language type-checks against,
+ * so it cannot drift from the implementation. That is what makes this different from
+ * writing a prompt that describes some functions.
+ */
+const EXPRESSIBLE = new Set(['string', 'number', 'boolean', 'enum', 'array', 'object']);
+export class ToolRegistry {
+    byId = new Map();
+    order = [];
+    register(tool) {
+        if (this.byId.has(tool.id)) {
+            throw new Error(`a tool is already registered as "${tool.id}"`);
+        }
+        if (!/@\d+$/.test(tool.id)) {
+            throw new Error(`tool id "${tool.id}" carries no version — ids are versioned as "name@1" so a ` +
+                `recorded trace stays readable after the tool's shape changes`);
+        }
+        const bad = inexpressible(tool.schema, '');
+        if (bad !== null) {
+            throw new Error(`tool "${tool.id}" has a schema field a schema cannot express: ${bad}`);
+        }
+        this.byId.set(tool.id, tool);
+        this.order.push(tool.id);
+    }
+    /** Registration order, so a prompt's tool list is stable and a trace stays comparable. */
+    ids() {
+        return this.order;
+    }
+    get(id) {
+        return this.byId.get(id);
+    }
+    /**
+     * Whether every tool an intent names still admits its arguments.
+     *
+     * A plain loop rather than a `map` and an `every`: this runs at the moment a
+     * buffered intent drains, which is inside a fixed step.
+     */
+    admits(toolIds, args, world) {
+        for (let i = 0; i < toolIds.length; i++) {
+            const id = toolIds[i];
+            if (id === undefined)
+                return false;
+            const tool = this.byId.get(id);
+            if (tool === undefined)
+                return false;
+            try {
+                if (!tool.admits(args[i], world))
+                    return false;
+            }
+            catch {
+                /* A consumer bug in a guard must not become an exception inside a tick. It
+                   becomes a refusal, the intent is discarded, and the policy floor covers. */
+                return false;
+            }
+        }
+        return true;
+    }
+}
+/** The dotted path of the first field no schema can express, or `null`. */
+function inexpressible(schema, path) {
+    if (!EXPRESSIBLE.has(schema.kind))
+        return path === '' ? schema.kind : path;
+    if (schema.kind === 'array')
+        return inexpressible(schema.of, path === '' ? 'of' : `${path}.of`);
+    if (schema.kind === 'object') {
+        for (const [name, field] of Object.entries(schema.fields)) {
+            const found = inexpressible(field, path === '' ? name : `${path}.${name}`);
+            if (found !== null)
+                return found;
+        }
+    }
+    return null;
+}

package/dist/tools/validate.d.ts

@@ -0,0 +1,24 @@
+import type { ToolSchema } from './registry.ts';
+export type ValidationResult = {
+    readonly ok: true;
+    readonly value: unknown;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+    readonly path: string;
+};
+/**
+ * Check a model's arguments against a tool's schema.
+ *
+ * **Never throws.** A model producing bad arguments is ordinary rather than
+ * exceptional — it is the thing schemas exist for — and putting the ordinary case on
+ * the exception path means every call site needs a `try` it will eventually forget.
+ *
+ * **An unknown field is a failure, not something to drop.** A model inventing a field
+ * is a signal: it means the prompt and the schema disagree about the tool's shape, and
+ * silently discarding it is how that disagreement survives a release. *What it costs:*
+ * a provider that helpfully adds metadata to a tool call breaks until the schema names
+ * it. *What would make it wrong:* if a mainstream provider does that unavoidably, the
+ * answer is a declared passthrough field rather than a blanket tolerance.
+ */
+export declare function validateArgs(schema: ToolSchema, args: unknown): ValidationResult;

package/dist/tools/validate.js

@@ -0,0 +1,80 @@
+/**
+ * Check a model's arguments against a tool's schema.
+ *
+ * **Never throws.** A model producing bad arguments is ordinary rather than
+ * exceptional — it is the thing schemas exist for — and putting the ordinary case on
+ * the exception path means every call site needs a `try` it will eventually forget.
+ *
+ * **An unknown field is a failure, not something to drop.** A model inventing a field
+ * is a signal: it means the prompt and the schema disagree about the tool's shape, and
+ * silently discarding it is how that disagreement survives a release. *What it costs:*
+ * a provider that helpfully adds metadata to a tool call breaks until the schema names
+ * it. *What would make it wrong:* if a mainstream provider does that unavoidably, the
+ * answer is a declared passthrough field rather than a blanket tolerance.
+ */
+export function validateArgs(schema, args) {
+    const failure = check(schema, args, '');
+    return failure ?? { ok: true, value: args };
+}
+function fail(path, reason) {
+    return { ok: false, reason, path };
+}
+function check(schema, value, path) {
+    switch (schema.kind) {
+        case 'string':
+        case 'number':
+        case 'boolean': {
+            const actual = typeof value;
+            if (actual !== schema.kind) {
+                return fail(path, `expected ${schema.kind}, received ${describe(value)}`);
+            }
+            return null;
+        }
+        case 'enum': {
+            if (typeof value !== 'string' || !schema.values.includes(value)) {
+                return fail(path, `expected one of ${schema.values.join(', ')}, received ${describe(value)}`);
+            }
+            return null;
+        }
+        case 'array': {
+            if (!Array.isArray(value))
+                return fail(path, `expected array, received ${describe(value)}`);
+            for (let i = 0; i < value.length; i++) {
+                const failure = check(schema.of, value[i], `${path}[${i}]`);
+                if (failure !== null)
+                    return failure;
+            }
+            return null;
+        }
+        case 'object': {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                return fail(path, `expected object, received ${describe(value)}`);
+            }
+            const record = value;
+            for (const [name, field] of Object.entries(schema.fields)) {
+                const at = path === '' ? name : `${path}.${name}`;
+                if (!(name in record))
+                    return fail(at, `missing required field`);
+                const failure = check(field, record[name], at);
+                if (failure !== null)
+                    return failure;
+            }
+            for (const name of Object.keys(record)) {
+                if (name in schema.fields)
+                    continue;
+                const at = path === '' ? name : `${path}.${name}`;
+                return fail(at, `unknown field, not in the schema`);
+            }
+            return null;
+        }
+        default:
+            return fail(path, `unrecognised schema kind`);
+    }
+}
+function describe(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}