ankka 0.6.0

package/dist/time.d.ts

@@ -0,0 +1,73 @@
+/** A point on the time line, to the nanosecond, in UTC. */
+export declare class Instant {
+    /** Seconds since 1970-01-01T00:00:00Z, negative before it. */
+    readonly epochSecond: number;
+    /** Nanoseconds within the second, 0 to 999_999_999. */
+    readonly nano: number;
+    private constructor();
+    static ofEpochSecond(epochSecond: number, nanoAdjustment?: number): Instant;
+    static ofEpochMilli(epochMilli: number): Instant;
+    static now(): Instant;
+    static fromDate(date: Date): Instant;
+    /** Parses ISO-8601 with `Z` or an offset and up to nine fractional digits. */
+    static parse(text: string): Instant;
+    toEpochMilli(): number;
+    /** Millisecond precision; sub-millisecond nanoseconds are dropped. */
+    toDate(): Date;
+    plusMillis(millis: number): Instant;
+    plus(duration: Duration): Instant;
+    isBefore(other: Instant): boolean;
+    isAfter(other: Instant): boolean;
+    equals(other: unknown): boolean;
+    static compare(a: Instant, b: Instant): number;
+    /** ISO-8601 in UTC with `Z` and 0, 3, 6 or 9 fractional digits, as the Scala codecs write it. */
+    toString(): string;
+    toJSON(): string;
+}
+/** The fraction text for a nanosecond count: none, or 3, 6 or 9 digits. */
+export declare function fractionOf(nano: number): string;
+/** An amount of time, to the nanosecond, as `java.time.Duration` holds and prints it. */
+export declare class Duration {
+    /** Whole seconds, negative for a negative duration. */
+    readonly seconds: number;
+    /** Nanoseconds within the second, 0 to 999_999_999, always non-negative (the Java convention). */
+    readonly nano: number;
+    private constructor();
+    static readonly ZERO: Duration;
+    static ofSeconds(seconds: number, nanoAdjustment?: number): Duration;
+    static ofMillis(millis: number): Duration;
+    static ofNanos(nanos: number): Duration;
+    static ofMinutes(minutes: number): Duration;
+    static ofHours(hours: number): Duration;
+    /** Parses the ISO-8601 form `java.time.Duration` reads: `PT1.5S`, `PT2H30M`, `P1DT12H`, `-PT1S`. */
+    static parse(text: string): Duration;
+    toMillis(): number;
+    toNanos(): number;
+    isNegative(): boolean;
+    isZero(): boolean;
+    plus(other: Duration): Duration;
+    equals(other: unknown): boolean;
+    static compare(a: Duration, b: Duration): number;
+    /** `java.time.Duration.toString`: `PT0S`, `PT1.5S`, `PT2H30M`, `PT-0.5S`. */
+    toString(): string;
+    toJSON(): string;
+}
+/** A calendar date with no zone, as its ISO-8601 text. */
+export declare class LocalDate {
+    readonly value: string;
+    private constructor();
+    static parse(text: string): LocalDate;
+    static of(year: number, month: number, day: number): LocalDate;
+    equals(other: unknown): boolean;
+    toString(): string;
+    toJSON(): string;
+}
+/** A date and time with no zone, as its ISO-8601 text. */
+export declare class LocalDateTime {
+    readonly value: string;
+    private constructor();
+    static parse(text: string): LocalDateTime;
+    equals(other: unknown): boolean;
+    toString(): string;
+    toJSON(): string;
+}

package/dist/time.js

@@ -0,0 +1,275 @@
+// Time values with the precision the encoding needs. `Date` holds milliseconds; an `Instant` in a
+// journal may carry nanoseconds, and `ENCODING.md` writes 0, 3, 6 or 9 fractional digits according to
+// the value. `Temporal` would do, but it is a global only from Node 26. These are the four small
+// value classes in between: immutable, comparable, convertible to and from `Date` where that makes sense.
+const NANOS_PER_SECOND = 1_000_000_000;
+const NANOS_PER_MILLI = 1_000_000;
+const INSTANT = /^(-?\d{4,9})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})$/;
+/** A point on the time line, to the nanosecond, in UTC. */
+export class Instant {
+    /** Seconds since 1970-01-01T00:00:00Z, negative before it. */
+    epochSecond;
+    /** Nanoseconds within the second, 0 to 999_999_999. */
+    nano;
+    constructor(epochSecond, nano) {
+        this.epochSecond = epochSecond;
+        this.nano = nano;
+        Object.freeze(this);
+    }
+    static ofEpochSecond(epochSecond, nanoAdjustment = 0) {
+        if (!Number.isInteger(epochSecond) || !Number.isInteger(nanoAdjustment)) {
+            throw new RangeError("Instant.ofEpochSecond takes integers");
+        }
+        const seconds = epochSecond + Math.floor(nanoAdjustment / NANOS_PER_SECOND);
+        const nano = ((nanoAdjustment % NANOS_PER_SECOND) + NANOS_PER_SECOND) % NANOS_PER_SECOND;
+        return new Instant(seconds, nano);
+    }
+    static ofEpochMilli(epochMilli) {
+        if (!Number.isInteger(epochMilli))
+            throw new RangeError("Instant.ofEpochMilli takes an integer");
+        return Instant.ofEpochSecond(Math.floor(epochMilli / 1000), (((epochMilli % 1000) + 1000) % 1000) * NANOS_PER_MILLI);
+    }
+    static now() {
+        return Instant.ofEpochMilli(Date.now());
+    }
+    static fromDate(date) {
+        const millis = date.getTime();
+        if (Number.isNaN(millis))
+            throw new RangeError("Instant.fromDate: invalid Date");
+        return Instant.ofEpochMilli(millis);
+    }
+    /** Parses ISO-8601 with `Z` or an offset and up to nine fractional digits. */
+    static parse(text) {
+        const m = INSTANT.exec(text);
+        if (!m)
+            throw new RangeError(`not an ISO-8601 instant: ${JSON.stringify(text)}`);
+        const [, year, month, day, hour, minute, second, fraction, zone] = m;
+        const millis = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+        const check = new Date(millis);
+        // Date.UTC rolls an out-of-range field over (month 13 becomes January); a real instant reads back as itself.
+        if (Number.isNaN(millis) ||
+            check.getUTCMonth() !== Number(month) - 1 ||
+            check.getUTCDate() !== Number(day) ||
+            check.getUTCHours() !== Number(hour) ||
+            check.getUTCMinutes() !== Number(minute) ||
+            check.getUTCSeconds() !== Number(second)) {
+            throw new RangeError(`not an ISO-8601 instant: ${JSON.stringify(text)}`);
+        }
+        let seconds = Math.floor(millis / 1000);
+        if (zone !== "Z") {
+            const sign = zone.startsWith("-") ? -1 : 1;
+            const offsetMinutes = sign * (Number(zone.slice(1, 3)) * 60 + Number(zone.slice(4, 6)));
+            seconds -= offsetMinutes * 60;
+        }
+        const nano = fraction ? Number(fraction.padEnd(9, "0")) : 0;
+        return new Instant(seconds, nano);
+    }
+    toEpochMilli() {
+        return this.epochSecond * 1000 + Math.floor(this.nano / NANOS_PER_MILLI);
+    }
+    /** Millisecond precision; sub-millisecond nanoseconds are dropped. */
+    toDate() {
+        return new Date(this.toEpochMilli());
+    }
+    plusMillis(millis) {
+        return Instant.ofEpochSecond(this.epochSecond, this.nano + millis * NANOS_PER_MILLI);
+    }
+    plus(duration) {
+        return Instant.ofEpochSecond(this.epochSecond + duration.seconds, this.nano + duration.nano);
+    }
+    isBefore(other) {
+        return Instant.compare(this, other) < 0;
+    }
+    isAfter(other) {
+        return Instant.compare(this, other) > 0;
+    }
+    equals(other) {
+        return other instanceof Instant && other.epochSecond === this.epochSecond && other.nano === this.nano;
+    }
+    static compare(a, b) {
+        return a.epochSecond !== b.epochSecond ? a.epochSecond - b.epochSecond : a.nano - b.nano;
+    }
+    /** ISO-8601 in UTC with `Z` and 0, 3, 6 or 9 fractional digits, as the Scala codecs write it. */
+    toString() {
+        const date = new Date(this.epochSecond * 1000);
+        const base = date.toISOString().slice(0, 19); // "YYYY-MM-DDTHH:MM:SS"
+        return base + fractionOf(this.nano) + "Z";
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+/** The fraction text for a nanosecond count: none, or 3, 6 or 9 digits. */
+export function fractionOf(nano) {
+    if (nano === 0)
+        return "";
+    const digits = String(nano).padStart(9, "0");
+    if (nano % NANOS_PER_MILLI === 0)
+        return "." + digits.slice(0, 3);
+    if (nano % 1000 === 0)
+        return "." + digits.slice(0, 6);
+    return "." + digits;
+}
+const DURATION = /^([+-]?)P(?:([+-]?\d+)D)?(?:T(?:([+-]?\d+)H)?(?:([+-]?\d+)M)?(?:([+-]?\d+)(?:[.,](\d{1,9}))?S)?)?$/i;
+/** An amount of time, to the nanosecond, as `java.time.Duration` holds and prints it. */
+export class Duration {
+    /** Whole seconds, negative for a negative duration. */
+    seconds;
+    /** Nanoseconds within the second, 0 to 999_999_999, always non-negative (the Java convention). */
+    nano;
+    constructor(seconds, nano) {
+        this.seconds = seconds;
+        this.nano = nano;
+        Object.freeze(this);
+    }
+    static ZERO = new Duration(0, 0);
+    static ofSeconds(seconds, nanoAdjustment = 0) {
+        if (!Number.isInteger(seconds) || !Number.isInteger(nanoAdjustment)) {
+            throw new RangeError("Duration.ofSeconds takes integers");
+        }
+        const s = seconds + Math.floor(nanoAdjustment / NANOS_PER_SECOND);
+        const n = ((nanoAdjustment % NANOS_PER_SECOND) + NANOS_PER_SECOND) % NANOS_PER_SECOND;
+        return new Duration(s, n);
+    }
+    static ofMillis(millis) {
+        if (!Number.isInteger(millis))
+            throw new RangeError("Duration.ofMillis takes an integer");
+        return Duration.ofSeconds(Math.floor(millis / 1000), (((millis % 1000) + 1000) % 1000) * NANOS_PER_MILLI);
+    }
+    static ofNanos(nanos) {
+        if (!Number.isInteger(nanos))
+            throw new RangeError("Duration.ofNanos takes an integer");
+        return Duration.ofSeconds(0, nanos);
+    }
+    static ofMinutes(minutes) {
+        return Duration.ofSeconds(minutes * 60);
+    }
+    static ofHours(hours) {
+        return Duration.ofSeconds(hours * 3600);
+    }
+    /** Parses the ISO-8601 form `java.time.Duration` reads: `PT1.5S`, `PT2H30M`, `P1DT12H`, `-PT1S`. */
+    static parse(text) {
+        const m = DURATION.exec(text);
+        if (!m || text.length <= 2)
+            throw new RangeError(`not an ISO-8601 duration: ${JSON.stringify(text)}`);
+        const [, sign, days, hours, minutes, secs, fraction] = m;
+        if (days === undefined && hours === undefined && minutes === undefined && secs === undefined) {
+            throw new RangeError(`not an ISO-8601 duration: ${JSON.stringify(text)}`);
+        }
+        let seconds = Number(days ?? 0) * 86400 + Number(hours ?? 0) * 3600 + Number(minutes ?? 0) * 60 + Number(secs ?? 0);
+        let nanos = fraction ? Number(fraction.padEnd(9, "0")) : 0;
+        if (secs?.startsWith("-"))
+            nanos = -nanos;
+        if (sign === "-") {
+            seconds = -seconds;
+            nanos = -nanos;
+        }
+        return Duration.ofSeconds(seconds, nanos);
+    }
+    toMillis() {
+        return this.seconds * 1000 + Math.floor(this.nano / NANOS_PER_MILLI);
+    }
+    toNanos() {
+        return this.seconds * NANOS_PER_SECOND + this.nano;
+    }
+    isNegative() {
+        return this.seconds < 0;
+    }
+    isZero() {
+        return this.seconds === 0 && this.nano === 0;
+    }
+    plus(other) {
+        return Duration.ofSeconds(this.seconds + other.seconds, this.nano + other.nano);
+    }
+    equals(other) {
+        return other instanceof Duration && other.seconds === this.seconds && other.nano === this.nano;
+    }
+    static compare(a, b) {
+        return a.seconds !== b.seconds ? a.seconds - b.seconds : a.nano - b.nano;
+    }
+    /** `java.time.Duration.toString`: `PT0S`, `PT1.5S`, `PT2H30M`, `PT-0.5S`. */
+    toString() {
+        if (this.isZero())
+            return "PT0S";
+        const total = this.seconds;
+        const hours = Math.trunc(total / 3600);
+        const minutes = Math.trunc((total % 3600) / 60);
+        let secs = total % 60;
+        let out = "PT";
+        if (hours !== 0)
+            out += `${hours}H`;
+        if (minutes !== 0)
+            out += `${minutes}M`;
+        if (secs === 0 && this.nano === 0 && out.length > 2)
+            return out;
+        // Java prints a negative duration with a fraction as e.g. PT-0.5S: seconds -1 and nanos 500_000_000 → "-0.5".
+        if (secs < 0 && this.nano > 0) {
+            if (secs === -1)
+                out += "-0";
+            else
+                out += String(secs + 1);
+        }
+        else {
+            out += String(secs);
+        }
+        if (this.nano > 0) {
+            const n = secs < 0 ? NANOS_PER_SECOND - this.nano : this.nano;
+            out += "." + String(n).padStart(9, "0").replace(/0+$/, "");
+        }
+        return out + "S";
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+const LOCAL_DATE = /^-?\d{4,9}-\d{2}-\d{2}$/;
+const LOCAL_DATE_TIME = /^-?\d{4,9}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+/** A calendar date with no zone, as its ISO-8601 text. */
+export class LocalDate {
+    value;
+    constructor(value) {
+        this.value = value;
+        Object.freeze(this);
+    }
+    static parse(text) {
+        if (!LOCAL_DATE.test(text) || Number.isNaN(Date.parse(text + "T00:00:00Z"))) {
+            throw new RangeError(`not an ISO-8601 date: ${JSON.stringify(text)}`);
+        }
+        return new LocalDate(text);
+    }
+    static of(year, month, day) {
+        return LocalDate.parse(`${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`);
+    }
+    equals(other) {
+        return other instanceof LocalDate && other.value === this.value;
+    }
+    toString() {
+        return this.value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}
+/** A date and time with no zone, as its ISO-8601 text. */
+export class LocalDateTime {
+    value;
+    constructor(value) {
+        this.value = value;
+        Object.freeze(this);
+    }
+    static parse(text) {
+        if (!LOCAL_DATE_TIME.test(text) || Number.isNaN(Date.parse(text + "Z"))) {
+            throw new RangeError(`not an ISO-8601 date-time: ${JSON.stringify(text)}`);
+        }
+        return new LocalDateTime(text);
+    }
+    equals(other) {
+        return other instanceof LocalDateTime && other.value === this.value;
+    }
+    toString() {
+        return this.value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/timedAction.d.ts

@@ -0,0 +1,20 @@
+import type { Metadata } from "./effects/common.ts";
+import type { ComponentClient } from "./client.ts";
+import type { HandlerTable } from "./handlers.ts";
+import { TimedActionEffects } from "./effects/stateless.ts";
+export declare abstract class TimedAction {
+    #private;
+    readonly effects: TimedActionEffects;
+    /** `ankka.timer` is the timer's id, `ankka.attempts` how many times it has fired. */
+    get metadata(): Metadata;
+    get client(): ComponentClient;
+    /** @internal */
+    get _kind(): "timed-action";
+    /** @internal */
+    _bind(metadata: Metadata, client: ComponentClient): void;
+}
+export interface TimedActionClass<C extends TimedAction = TimedAction> {
+    new (): C;
+    readonly componentId: string;
+    readonly actions: HandlerTable<C>;
+}

package/dist/timedAction.js

@@ -0,0 +1,28 @@
+// A timed action: a call the platform makes later. Scheduled through `client.timers`; the sidecar's
+// sweeper delivers it here, retrying a failure with backoff.
+//
+//   static readonly actions = { remind: action("remind", s.string, (t: Reminder, id) => t.remind(id)) }
+import { TimedActionEffects } from "./effects/stateless.js";
+export class TimedAction {
+    effects = new TimedActionEffects();
+    #metadata = {};
+    #client;
+    /** `ankka.timer` is the timer's id, `ankka.attempts` how many times it has fired. */
+    get metadata() {
+        return this.#metadata;
+    }
+    get client() {
+        if (!this.#client)
+            throw new Error("client is only available inside an action");
+        return this.#client;
+    }
+    /** @internal */
+    get _kind() {
+        return "timed-action";
+    }
+    /** @internal */
+    _bind(metadata, client) {
+        this.#metadata = metadata;
+        this.#client = client;
+    }
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.6.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+// Written by scripts/proto.ts from package.json; do not edit. 0.0.0 in the tree, the tag's version in a release.
+export const VERSION = "0.6.0";

package/dist/view.d.ts

@@ -0,0 +1,37 @@
+import type { Shape } from "./codec.ts";
+import type { Metadata } from "./effects/common.ts";
+import type { ComponentClient } from "./client.ts";
+import type { ComponentRef } from "./client.ts";
+import { ViewEffects, type ViewEffect } from "./effects/stateless.ts";
+type MaybePromise<T> = T | Promise<T>;
+export declare abstract class View<E, Row> {
+    #private;
+    readonly effects: ViewEffects<Row>;
+    /** The current row, or `null` when there is none yet. */
+    get row(): Row | null;
+    /** The change's metadata: `ce-subject` is the source instance's id, `ankka.sequence` its sequence number. */
+    get metadata(): Metadata;
+    /** The id of the source instance the change came from. */
+    get subject(): string;
+    get client(): ComponentClient;
+    /** @internal */
+    get _kind(): "view";
+    /** What `event` does to the row. */
+    abstract onChange(event: E): MaybePromise<ViewEffect<Row>>;
+    /** The source was deleted. The row goes with it unless this says otherwise — an order history keeps a checked-out cart's row. */
+    onDelete(): MaybePromise<ViewEffect<Row>>;
+    /** @internal */
+    _bind(row: Row | null, metadata: Metadata, client: ComponentClient): void;
+}
+export interface ViewClass<E = unknown, Row = unknown, C extends View<E, Row> = View<E, Row>> {
+    new (): C;
+    readonly componentId: string;
+    /** The component whose changes feed the view, or `topic`. */
+    readonly source?: ComponentRef;
+    readonly topic?: string;
+    readonly events: Shape<E>;
+    readonly row: Shape<Row>;
+    /** The query names the view answers; `get` and `all` by default. */
+    readonly queries?: readonly string[];
+}
+export {};

package/dist/view.js

@@ -0,0 +1,52 @@
+// A view: a queryable projection of a source's changes. The sidecar runs the projection and stores the
+// rows; this process only says what each event does to a row.
+//
+//   export class CartRows extends View<ShoppingCartEvent, CartRow> {
+//     static readonly componentId = "cart-rows"
+//     static readonly source = ShoppingCartEntity
+//     static readonly events = ShoppingCartEntity.events
+//     static readonly row = jsonCodec(CartRow, "cart-row")
+//     onChange(event) { ... return this.effects.updateRow(...) }
+//   }
+import { ViewEffects } from "./effects/stateless.js";
+export class View {
+    effects = new ViewEffects();
+    #row = null;
+    #metadata = {};
+    #client;
+    #bound = false;
+    /** The current row, or `null` when there is none yet. */
+    get row() {
+        if (!this.#bound)
+            throw new Error("row is only available inside onChange or onDelete");
+        return this.#row;
+    }
+    /** The change's metadata: `ce-subject` is the source instance's id, `ankka.sequence` its sequence number. */
+    get metadata() {
+        return this.#metadata;
+    }
+    /** The id of the source instance the change came from. */
+    get subject() {
+        return this.#metadata["ce-subject"] ?? "";
+    }
+    get client() {
+        if (!this.#client)
+            throw new Error("client is only available inside onChange or onDelete");
+        return this.#client;
+    }
+    /** @internal */
+    get _kind() {
+        return "view";
+    }
+    /** The source was deleted. The row goes with it unless this says otherwise — an order history keeps a checked-out cart's row. */
+    onDelete() {
+        return this.effects.deleteRow();
+    }
+    /** @internal */
+    _bind(row, metadata, client) {
+        this.#row = row;
+        this.#metadata = metadata;
+        this.#client = client;
+        this.#bound = true;
+    }
+}

package/dist/workflow.d.ts

@@ -0,0 +1,33 @@
+import type { Shape } from "./codec.ts";
+import type { CommandContext } from "./context.ts";
+import type { HandlerTable } from "./handlers.ts";
+import type { ComponentClient } from "./client.ts";
+import { StepEffects, WorkflowEffects, type WorkflowSettings } from "./effects/workflow.ts";
+export declare abstract class Workflow<S> {
+    #private;
+    /** Inside a command handler. */
+    readonly effects: WorkflowEffects<S>;
+    /** Inside a step. */
+    readonly stepEffects: StepEffects<S>;
+    get state(): S;
+    get entityId(): string;
+    get context(): CommandContext;
+    get client(): ComponentClient;
+    /** @internal */
+    get _kind(): "workflow";
+    abstract emptyState(): S;
+    /** @internal */
+    _bindInstance(entityId: string): void;
+    /** @internal */
+    _bindCommand(state: S, context: CommandContext, client: ComponentClient): void;
+    /** @internal */
+    _unbindCommand(): void;
+}
+export interface WorkflowClass<S = unknown, C extends Workflow<S> = Workflow<S>> {
+    new (): C;
+    readonly componentId: string;
+    readonly state: Shape<S>;
+    readonly handlers: HandlerTable<C>;
+    readonly steps: HandlerTable<C>;
+    readonly settings?: WorkflowSettings;
+}

package/dist/workflow.js

@@ -0,0 +1,61 @@
+// A workflow: a durable multi-step process. Commands change state and start steps; steps run in this
+// process, one at a time per instance, and say what happens next. The sidecar journals every
+// transition and drives the steps, retries and timeouts — a step that throws is retried and eventually
+// compensated as `settings` declares.
+//
+//   static readonly steps = { reserve: step("reserve", (w: CheckoutWorkflow) => w.reserve()), charge: step("charge", s.int, (w, q) => w.charge(q)) }
+//   static readonly settings = workflowSettings({ steps: { charge: { recovery: { maxRetries: 1, failoverTo: "compensate" } } } })
+import { StepEffects, WorkflowEffects } from "./effects/workflow.js";
+export class Workflow {
+    /** Inside a command handler. */
+    effects = new WorkflowEffects();
+    /** Inside a step. */
+    stepEffects = new StepEffects();
+    #state;
+    #entityId;
+    #context;
+    #client;
+    #bound = false;
+    get state() {
+        if (!this.#bound)
+            throw new Error("state is only available inside a handler or a step");
+        return this.#state;
+    }
+    get entityId() {
+        if (this.#entityId === undefined)
+            throw new Error("entityId is only available once the workflow is bound to an instance");
+        return this.#entityId;
+    }
+    get context() {
+        if (!this.#context)
+            throw new Error("context is only available inside a handler or a step");
+        return this.#context;
+    }
+    get client() {
+        if (!this.#client)
+            throw new Error("client is only available inside a handler or a step");
+        return this.#client;
+    }
+    /** @internal */
+    get _kind() {
+        return "workflow";
+    }
+    /** @internal */
+    _bindInstance(entityId) {
+        this.#entityId = entityId;
+    }
+    /** @internal */
+    _bindCommand(state, context, client) {
+        this.#state = state;
+        this.#context = context;
+        this.#client = client;
+        this.#bound = true;
+    }
+    /** @internal */
+    _unbindCommand() {
+        this.#state = undefined;
+        this.#context = undefined;
+        this.#client = undefined;
+        this.#bound = false;
+    }
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "ankka",
+  "version": "0.6.0",
+  "description": "Build services on ankka in TypeScript: entities, views, workflows, agents and endpoints hosted by the ankka sidecar.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=22.22.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "ankka-source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testkit": {
+      "ankka-source": "./src/testkit/index.ts",
+      "types": "./dist/testkit/index.d.ts",
+      "default": "./dist/testkit/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thinkmorestupidless/ankka.git",
+    "directory": "sdks/typescript"
+  },
+  "homepage": "https://docs.ankka.cloud/",
+  "keywords": [
+    "ankka",
+    "event-sourcing",
+    "actors",
+    "agents",
+    "workflows",
+    "sidecar"
+  ],
+  "scripts": {
+    "proto": "node scripts/proto.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "node --conditions=ankka-source --test 'test/**/*.test.ts' 'examples/**/*.test.ts'",
+    "test:slow": "ANKKA_SLOW=1 node --conditions=ankka-source --test 'test/**/*.test.ts' 'examples/**/*.test.ts'",
+    "conformance": "node --conditions=ankka-source bin/conformance.ts",
+    "example": "node --conditions=ankka-source examples/shopping-cart/main.ts"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.15.0",
+    "@connectrpc/connect": "^2.2.0",
+    "@connectrpc/connect-node": "^2.2.0"
+  },
+  "peerDependencies": {
+    "@testcontainers/postgresql": "^12.1.0",
+    "testcontainers": "^12.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@testcontainers/postgresql": {
+      "optional": true
+    },
+    "testcontainers": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.73.0",
+    "@bufbuild/protoc-gen-es": "^2.15.0",
+    "@testcontainers/postgresql": "^12.1.0",
+    "@types/node": "^24.19.0",
+    "testcontainers": "^12.1.0",
+    "typescript": "^7.0.2"
+  }
+}