@toa.io/core 1.0.0-alpha.28 → 1.0.0-alpha.282

package/test/receiver.test.js

@@ -1,15 +1,22 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-const { merge } = require('@toa.io/generic')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
+import { merge } from '@toa.io/generic'
 
-jest.mock('../src/connector')
+import { Connector } from '../src/connector.js'
 
-const { Connector } = /** @type {{ Connector: jest.Mock<toa.core.Connector>}} */ require('../src/connector')
+// the fixtures are not connectors, so a dependency is recorded rather than linked
+const depends = mock.method(Connector.prototype, 'depends', () => undefined)
 
-const { Receiver } = require('../src/receiver')
-const fixtures = require('./receiver.fixtures')
+const dependencies = (instance) => depends.mock.calls
+  .filter((call) => call.this === instance)
+  .map((call) => call.arguments[0])
+
+import { Receiver } from '../src/receiver.js'
+import * as fixtures from './receiver.fixtures.js'
 
 /** @type {toa.core.Receiver} */
 let receiver
@@ -18,15 +25,16 @@ let receiver
 let definition
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 
   definition = clone(fixtures.definition)
   receiver = new Receiver(fixtures.definition, fixtures.local, fixtures.bridge)
 })
 
 it('should depend on local, bridge', () => {
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.local)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
+  assert.ok(dependencies(receiver).some((one) => isDeepStrictEqual(one, fixtures.local)))
+  assert.ok(dependencies(receiver).some((one) => isDeepStrictEqual(one, fixtures.bridge)))
 })
 
 it('should apply', async () => {
@@ -34,11 +42,12 @@ it('should apply', async () => {
 
   await receiver.receive({ payload })
 
-  expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
+  assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
 })
 
-it.each([[false], [true]])('should pass UI extensions (adaptive: %s)', async (adaptive) => {
-  jest.clearAllMocks()
+for (const [adaptive] of [[false], [true]])
+   it(`should pass UI extensions (adaptive: ${adaptive})`, async () => {
+  resetCalls()
 
   definition.adaptive = adaptive
   receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
@@ -49,12 +58,12 @@ it.each([[false], [true]])('should pass UI extensions (adaptive: %s)', async (ad
 
   await receiver.receive(message)
 
-  const request = adaptive ? await fixtures.bridge.request.mock.results[0].value : { input: payload }
+  const request = adaptive ? await fixtures.bridge.request.mock.calls[0].result : { input: payload }
   const expected = merge(clone(request), extension)
 
-  const argument = fixtures.local.invoke.mock.calls[0][1]
+  const argument = fixtures.local.invoke.mock.calls[0].arguments[1]
 
-  expect(argument).toStrictEqual(expected)
+  assert.deepStrictEqual(argument, expected)
 })
 
 describe('conditioned', () => {
@@ -67,15 +76,15 @@ describe('conditioned', () => {
     const payload = { foo: 'bar' }
     await receiver.receive({ payload })
 
-    expect(fixtures.bridge.condition).toHaveBeenCalledWith(payload)
-    expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
+    assert.ok(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], payload)))
+    assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
   })
 
   it('should not apply if condition is false', async () => {
     const payload = { reject: true }
     await receiver.receive({ payload })
 
-    expect(fixtures.local.invoke).not.toHaveBeenCalled()
+    assert.strictEqual(fixtures.local.invoke.mock.callCount(), 0)
   })
 })
 
@@ -89,7 +98,21 @@ describe('adaptive', () => {
     const payload = { reject: true }
     await receiver.receive({ payload })
 
-    expect(fixtures.local.invoke)
-      .toHaveBeenCalledWith(definition.operation, await fixtures.bridge.request.mock.results[0].value)
+    const request = await fixtures.bridge.request.mock.calls[0].result
+
+    assert.ok(fixtures.local.invoke.mock.calls.some((call) =>
+      call.arguments.length === 2 &&
+      isDeepStrictEqual(call.arguments[0], definition.operation) &&
+      isDeepStrictEqual(call.arguments[1], request)))
   })
 })
+
+function resetCalls (target = [assert, clone, fixtures], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
+
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/test/reflection.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { generate } = require('randomstring')
-const { Reflection, Connector } = require('../')
+import { generate } from 'randomstring'
+import { Reflection, Connector } from '../src/index.js'
 
 it('should export', () => {
-  expect(Reflection).toBeDefined()
+  assert.notStrictEqual(Reflection, undefined)
 })
 
 /** @type {toa.core.Reflection<string>} */
@@ -20,11 +21,11 @@ beforeEach(() => {
 })
 
 it('should be a Connector', () => {
-  expect(reflection).toBeInstanceOf(Connector)
+  assert.ok(reflection instanceof Connector)
 })
 
 it('should reflect', async () => {
   await reflection.connect()
 
-  expect(reflection.value).toStrictEqual(value)
+  assert.deepStrictEqual(reflection.value, value)
 })

package/test/state.fixtures.js

@@ -1,47 +1,42 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const storage = {
+export const storage = {
   name: 'dummy',
-  get: jest.fn(() => ({ id: generate() })),
-  find: jest.fn(() => ([{ id: generate() }])),
-  add: jest.fn(() => true),
-  set: jest.fn(() => true),
-  store: jest.fn(() => true)
+  get: mock.fn(() => ({ id: generate() })),
+  find: mock.fn(() => ([{ id: generate() }])),
+  add: mock.fn(() => true),
+  set: mock.fn(() => true),
+  store: mock.fn(() => true),
+  massStore: mock.fn(() => true),
+  upsert: mock.fn(() => ({ id: generate() })),
+  ensure: mock.fn((query, properties, state) => state)
 }
 
-const factory = {
-  object: jest.fn(() => ({ [generate()]: generate() })),
-  objects: jest.fn(() => ({ [generate()]: generate() }))
+export const factory = {
+  object: mock.fn(() => ({ [generate()]: generate() })),
+  objects: mock.fn(() => ({ [generate()]: generate() }))
 }
 
-const query = generate()
+export const query = generate()
 
-const entity = {
-  get: jest.fn(() => ({ [generate()]: generate() })),
-  event: jest.fn(() => ({
-    state: { [generate()]: generate() }, changeset: { [generate()]: generate() }
-  }))
+export const entity = {
+  get: mock.fn(() => ({ [generate()]: generate() })),
+  event: mock.fn(() => ({ state: { [generate()]: generate() } }))
 }
 
-const initial = {
+export const initial = {
   initial: true, ...entity
 }
 
-const unchanged = {
+export const unchanged = {
   ...entity,
-  event: jest.fn(() => ({ state: { [generate()]: generate() }, changeset: {} }))
+  event: mock.fn(() => ({ state: { [generate()]: generate() } }))
 }
 
-const emitter = {
-  emit: jest.fn()
+// a legacy outbox: no storage capability, so `publish` emits inline
+export const outbox = {
+  row: mock.fn((event) => ({ id: generate(), lane: 0, published: false, pending: 0, event })),
+  publish: mock.fn()
 }
-
-exports.storage = storage
-exports.factory = factory
-exports.emitter = emitter
-exports.query = query
-exports.entity = entity
-exports.initial = initial
-exports.unchanged = unchanged

package/test/state.test.js

@@ -1,46 +1,99 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { State } = require('../src/state')
-const fixtures = require('./state.fixtures')
+import { State } from '../src/state.js'
+import * as fixtures from './state.fixtures.js'
 
 let state
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 
-  state = new State(fixtures.storage, fixtures.factory, fixtures.emitter)
+  state = new State(fixtures.storage, fixtures.factory, fixtures.outbox)
 })
 
 it('should provide object', async () => {
   const entity = await state.object(fixtures.query)
 
-  expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
-  expect(entity).toStrictEqual(fixtures.factory.object.mock.results[0].value)
-  expect(fixtures.factory.object).toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value)
+  assert.ok(fixtures.storage.get.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.query)))
+  assert.deepStrictEqual(entity, fixtures.factory.object.mock.calls[0].result)
+  assert.ok(fixtures.factory.object.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], true)))
 })
 
-it('should provide objects', async () => {
-  const set = await state.objects(fixtures.query)
+it('should provide read-only object', async () => {
+  await state.object(fixtures.query, false)
 
-  expect(fixtures.storage.find).toHaveBeenCalledWith(fixtures.query)
-  expect(set).toStrictEqual(fixtures.factory.objects.mock.results[0].value)
-  expect(fixtures.factory.objects).toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value)
+  assert.ok(fixtures.factory.object.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], false)))
+})
+
+it('should provide read-only objects', async () => {
+  await state.objects(fixtures.query, false)
+
+  assert.ok(fixtures.factory.objects.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], fixtures.storage.find.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], undefined) && isDeepStrictEqual(call.arguments[2], false)))
 })
 
 it('should store entity', async () => {
   await state.commit(fixtures.initial)
 
-  expect(fixtures.storage.store).toHaveBeenCalledWith(fixtures.initial.get.mock.results[0].value)
+  assert.ok(fixtures.storage.store.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.initial.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], fixtures.outbox.row.mock.calls[0].result)))
 })
 
-it('should emit', async () => {
+it('should publish the row', async () => {
   await state.commit(fixtures.entity)
 
-  expect(fixtures.emitter.emit).toHaveBeenCalledWith(fixtures.entity.event.mock.results[0].value)
+  assert.ok(fixtures.outbox.row.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.entity.event.mock.calls[0].result)))
+  assert.ok(fixtures.outbox.publish.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)))
 })
 
-it('should not emit if state has not been changed', async () => {
-  await state.commit(fixtures.unchanged)
+it('should not publish if the write did not happen', async () => {
+  fixtures.storage.store.mock.mockImplementationOnce(() => false)
 
-  expect(fixtures.emitter.emit).not.toHaveBeenCalled()
+  await state.commit(fixtures.entity)
+
+  assert.strictEqual(fixtures.outbox.publish.mock.callCount(), 0)
 })
+
+it('should build the row before the write', async () => {
+  // the storage commits the row in the same transaction, so it must already exist
+  fixtures.storage.store.mock.mockImplementationOnce((_, row) => {
+    assert.notStrictEqual(row, undefined)
+
+    return true
+  })
+
+  
+  await state.commit(fixtures.entity)
+})
+
+describe('assignment', () => {
+  const changeset = { query: 'q', export: () => ({ foo: 1 }) }
+
+  it('should pass the row to upsert and publish it', async () => {
+    const result = await state.apply(changeset, { foo: 1 })
+
+    assert.ok(fixtures.storage.upsert.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], changeset.query) && isDeepStrictEqual(call.arguments[1], { foo: 1 }) && isDeepStrictEqual(call.arguments[2], fixtures.outbox.row.mock.calls[0].result)))
+
+    assert.ok(fixtures.outbox.publish.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)))
+    assert.deepStrictEqual(result, fixtures.storage.upsert.mock.calls[0].result)
+  })
+
+  it('should fill the state a storage without the outbox left alone', async () => {
+    await state.apply(changeset, { foo: 1 })
+
+    const row = fixtures.outbox.row.mock.calls[0].result
+
+    assert.deepStrictEqual(row.event.state, fixtures.storage.upsert.mock.calls[0].result)
+    assert.deepStrictEqual(row.event.input, { foo: 1 })
+  })
+})
+
+function resetCalls (target = [assert, fixtures], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
+
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/test/transmission.fixtures.js

@@ -1,15 +1,13 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 const binding = (index) => ({
-  request: jest.fn(async (request) => {
+  request: mock.fn(async (request) => {
     if (request?.pick !== undefined && request.pick !== index) return false
 
     return { output: generate() }
   })
 })
 
-const bindings = [0, 1, 2, 3, 4].map(binding)
-
-exports.bindings = bindings
+export const bindings = [0, 1, 2, 3, 4].map(binding)

package/test/transmission.test.js

@@ -1,16 +1,24 @@
-'use strict'
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-jest.mock('../src/connector')
+import { Connector } from '../src/connector.js'
 
-const { Connector } = require('../src/connector')
-const { Transmission } = require('../src/transmission')
-const { codes } = require('../src/exceptions')
-const fixtures = require('./transmission.fixtures')
+// the fixtures are not connectors, so a dependency is recorded rather than linked
+const depends = mock.method(Connector.prototype, 'depends', () => undefined)
+
+const dependencies = (instance) => depends.mock.calls
+  .filter((call) => call.this === instance)
+  .map((call) => call.arguments[0])
+import { Transmission } from '../src/transmission.js'
+import { codes } from '../src/exceptions.js'
+import * as fixtures from './transmission.fixtures.js'
 
 let transmission
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 })
 
 beforeEach(() => {
@@ -18,29 +26,39 @@ beforeEach(() => {
 })
 
 it('should be instance of Connector depending on bindings', () => {
-  expect(transmission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bindings)
+  assert.ok(transmission instanceof Connector)
+  assert.ok(dependencies(transmission).some((one) => isDeepStrictEqual(one, fixtures.bindings)))
 })
 
 it('should pass arguments and return value', async () => {
   const request = { foo: 'bar' }
   const result = await transmission.request(request)
 
-  expect(fixtures.bindings[0].request).toHaveBeenCalledWith(request)
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+  assert.ok(fixtures.bindings[0].request.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], request)))
+  assert.strictEqual(result, await fixtures.bindings[0].request.mock.calls[0].result)
 })
 
 it('should pick bindings sequentially', async () => {
   let result = await transmission.request()
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+  assert.strictEqual(result, await fixtures.bindings[0].request.mock.calls[0].result)
 
   result = await transmission.request({ pick: 1 })
-  expect(result).toBe(await fixtures.bindings[1].request.mock.results[0]?.value)
+  assert.strictEqual(result, await fixtures.bindings[1].request.mock.calls[0]?.result)
 })
 
 it('should throw exception if none succeeded', async () => {
-  await expect(transmission.request({ pick: 5 })).rejects.toMatchObject({ code: codes.Transmission })
+  await assert.rejects(transmission.request({ pick: 5 }), (error) => { assert.partialDeepStrictEqual(error, { code: codes.Transmission }); return true })
 
   fixtures.bindings.forEach((binding) =>
-    expect(binding.request).toHaveBeenCalled())
+    assert.ok(binding.request.mock.callCount() > 0))
 })
+
+function resetCalls (target = [assert, depends, dependencies, fixtures], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
+
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/types/atomicity.d.ts

@@ -0,0 +1,58 @@
+// noinspection ES6UnusedImports
+
+import { Connector } from './connector.js'
+
+declare namespace toa.core {
+
+  namespace atomicity {
+
+    /**
+     * What one group of replicas decides together, in one place. The decisions here are the
+     * ones processes cannot arrange by talking to each other: they need a single arbiter and a
+     * step indivisible from its point of view.
+     */
+    interface Atom extends Connector {
+      /**
+       * An exclusive claim on slots of `0..total`: while this replica holds one, no other
+       * replica of the group does. Answered from memory, so it costs nothing to ask.
+       *
+       * `null` while this replica owns nothing — after a restart, during a rollout, or while
+       * coordination is unreachable. Whoever asks must be able to stand down: acting on a
+       * claim that cannot be supported is a different guarantee, not a degraded one.
+       */
+      slots (total: number): number[] | null
+
+      /**
+       * Debt the group has run up under each key, in milliseconds. Every call adds its own
+       * deltas and reads back where the group stands, so a replica reports what it alone has
+       * spent and still decides on what all of them have.
+       *
+       * Rejects where there is nothing to arbitrate through.
+       */
+      meter (keys: string[], deltas: number[]): Promise<number[]>
+
+      /**
+       * Runs `routine` holding `keys`, and while it holds them no other replica of the group
+       * does. Waits for as long as it takes to acquire them.
+       *
+       * The lease is extended for as long as the routine runs. An extension that fails aborts
+       * the signal the routine is given, which is the only way it learns it no longer holds
+       * what it is working under.
+       *
+       * Rejects where there is nothing to arbitrate through.
+       */
+      lock<T> (keys: string | string[],
+        routine: (signal: AbortSignal, context: unknown) => Promise<T>): Promise<T>
+    }
+
+    interface Factory {
+      /** @param group what the replicas deciding together have in common */
+      atom (group: string, options?: object): Atom
+    }
+
+  }
+
+}
+
+export type Atom = toa.core.atomicity.Atom
+export type Factory = toa.core.atomicity.Factory

package/types/bindings.d.ts

@@ -1,26 +1,28 @@
-import * as _core from './index'
+import * as _core from './index.js'
 
-declare namespace toa.core.bindings{
+declare namespace toa.core.bindings {
 
   type Properties = {
     async?: boolean
   }
 
-  interface Consumer extends _core.Connector{
+  interface Consumer extends _core.Connector {
     request (request: Request): Promise<_core.Reply>
+
+    task (request: Request): Promise<void>
   }
 
-  interface Emitter extends _core.Connector{
+  interface Emitter extends _core.Connector {
     emit (message: _core.Message): Promise<void>
   }
 
-  interface Broadcast<L> extends _core.Connector{
+  interface Broadcast<L> extends _core.Connector {
     transmit<T> (label: L, payload: T): Promise<void>
 
     receive<T> (label: L, callback: (payload: T) => void | Promise<void>): Promise<void>
   }
 
-  interface Factory{
+  interface Factory {
     producer? (locator: _core.Locator, endpoints: Array<string>, producer: _core.Component): _core.Connector
 
     consumer? (locator: _core.Locator, endpoint: string): Consumer

package/types/bridges.ts

@@ -1,5 +1,6 @@
-import type { Request, Reply } from './request'
-import type { Context } from './context'
+import type { Request, Reply } from './request.js'
+import type { Context } from './context.js'
+import type { Connector } from './connector.js'
 
 export interface Algorithm {
   mount: (context?: Context) => Promise<void>
@@ -27,4 +28,6 @@ export interface Factory {
   event?: (path: string, label: string) => Event
 
   receiver?: (path: string, label: string) => Receiver
+
+  rc?: (path: string, context: Context) => Promise<{ preflight?: Connector, settle?: Connector, dispose?: Connector } | undefined>
 }

package/types/component.d.ts

@@ -1,9 +1,12 @@
-import { Connector } from './connector'
-import { Locator } from './locator'
-import { Request } from './request'
+import { Connector } from './connector.js'
+import { Locator } from './locator.js'
+import { Request } from './request.js'
+import { Operation } from './operations.js'
 
-export interface Component extends Connector{
+export class Component extends Connector {
   locator: Locator
 
+  constructor (locator: Locator, operations: Record<string, Operation>)
+
   invoke<T = any> (endpoint: string, request: Request): Promise<T>
 }

package/types/context.d.ts

@@ -1,11 +1,14 @@
-import * as _request from './request'
+import * as _request from './request.js'
+import { Locator } from './locator.js'
 import * as _reply from './reply'
-import * as _extensions from './extensions'
-import * as _connector from './connector'
+import * as _extensions from './extensions.js'
+import * as _connector from './connector.js'
 
 export interface Context extends _connector.Connector{
   aspects: _extensions.Aspect[]
 
+  locator: Locator
+
   /**
    * Calls local endpoint
    */

package/types/entity.d.ts

@@ -1,5 +1,5 @@
-import * as _event from './event'
-import * as _storages from './storages'
+import * as _event from './event.js'
+import * as _storages from './storages.js'
 
 declare namespace toa.core {
 
@@ -8,9 +8,9 @@ declare namespace toa.core {
     interface Factory {
       init(id: string): Entity
 
-      object(record: Object): Entity
+      object(record: Object, mutable?: boolean): Entity
 
-      objects(recordset: Object[]): Entity[]
+      objects(recordset: Object[], init?: string[], mutable?: boolean): Entity[]
 
       changeset(query: _storages.Query): Changeset
     }

package/types/event.d.ts

@@ -1,4 +1,4 @@
-import * as _state from './state'
+import * as _state from './state.js'
 
 declare namespace toa.core {