@humwick/server 0.130.1 → 0.130.2

package/node_modules/@humwick/kernel/LICENSE

@@ -1,167 +0,0 @@
-# PolyForm Shield License 1.0.0
-
-<https://polyformproject.org/licenses/shield/1.0.0>
-
-## Acceptance
-
-In order to get any license under these terms, you must agree
-to them as both strict obligations and conditions to all
-your licenses.
-
-## Copyright License
-
-The licensor grants you a copyright license for the
-software to do everything you might do with the software
-that would otherwise infringe the licensor's copyright
-in it for any permitted purpose.  However, you may
-only distribute the software according to [Distribution
-License](#distribution-license) and make changes or new works
-based on the software according to [Changes and New Works
-License](#changes-and-new-works-license).
-
-## Distribution License
-
-The licensor grants you an additional copyright license
-to distribute copies of the software.  Your license
-to distribute covers distributing the software with
-changes and new works permitted by [Changes and New Works
-License](#changes-and-new-works-license).
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of
-the software from you also gets a copy of these terms or the
-URL for them above, as well as copies of any plain-text lines
-beginning with `Required Notice:` that the licensor provided
-with the software.  For example:
-
-> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
-
-## Changes and New Works License
-
-The licensor grants you an additional copyright license to
-make changes and new works based on the software for any
-permitted purpose.
-
-## Patent License
-
-The licensor grants you a patent license for the software that
-covers patent claims the licensor can license, or becomes able
-to license, that you would infringe by using the software.
-
-## Noncompete
-
-Any purpose is a permitted purpose, except for providing any
-product that competes with the software or any product the
-licensor or any of its affiliates provides using the software.
-
-## Competition
-
-Goods and services compete even when they provide functionality
-through different kinds of interfaces or for different technical
-platforms.  Applications can compete with services, libraries
-with plugins, frameworks with development tools, and so on,
-even if they're written in different programming languages
-or for different computer architectures.  Goods and services
-compete even when provided free of charge.  If you market a
-product as a practical substitute for the software or another
-product, it definitely competes.
-
-## New Products
-
-If you are using the software to provide a product that does
-not compete, but the licensor or any of its affiliates brings
-your product into competition by providing a new version of
-the software or another product using the software, you may
-continue using versions of the software available under these
-terms beforehand to provide your competing product, but not
-any later versions.
-
-## Discontinued Products
-
-You may begin using the software to compete with a product
-or service that the licensor or any of its affiliates has
-stopped providing, unless the licensor includes a plain-text
-line beginning with `Licensor Line of Business:` with the
-software that mentions that line of business.  For example:
-
-> Licensor Line of Business: YoyodyneCMS Content Management
-System (http://example.com/cms)
-
-## Sales of Business
-
-If the licensor or any of its affiliates sells a line of
-business developing the software or using the software
-to provide a product, the buyer can also enforce
-[Noncompete](#noncompete) for that product.
-
-## Fair Use
-
-You may have "fair use" rights for the software under the
-law. These terms do not limit them.
-
-## No Other Rights
-
-These terms do not allow you to sublicense or transfer any of
-your licenses to anyone else, or prevent the licensor from
-granting licenses to anyone else.  These terms do not imply
-any other licenses.
-
-## Patent Defense
-
-If you make any written claim that the software infringes or
-contributes to infringement of any patent, your patent license
-for the software granted under these terms ends immediately. If
-your company makes such a claim, your patent license ends
-immediately for work on behalf of your company.
-
-## Violations
-
-The first time you are notified in writing that you have
-violated any of these terms, or done anything with the software
-not covered by your licenses, your licenses can nonetheless
-continue if you come into full compliance with these terms,
-and take practical steps to correct past violations, within
-32 days of receiving notice.  Otherwise, all your licenses
-end immediately.
-
-## No Liability
-
-***As far as the law allows, the software comes as is, without
-any warranty or condition, and the licensor will not be liable
-to you for any damages arising out of these terms or the use
-or nature of the software, under any kind of legal claim.***
-
-## Definitions
-
-The **licensor** is the individual or entity offering these
-terms, and the **software** is the software the licensor makes
-available under these terms.
-
-A **product** can be a good or service, or a combination
-of them.
-
-**You** refers to the individual or entity agreeing to these
-terms.
-
-**Your company** is any legal entity, sole proprietorship,
-or other kind of organization that you work for, plus all
-its affiliates.
-
-**Affiliates** means the other organizations than an
-organization has control over, is under the control of, or is
-under common control with.
-
-**Control** means ownership of substantially all the assets of
-an entity, or the power to direct its management and policies
-by vote, contract, or otherwise.  Control can be direct or
-indirect.
-
-**Your licenses** are all the licenses granted to you for the
-software under these terms.
-
-**Use** means anything you do with the software requiring one
-of your licenses.
-
-Required Notice: Copyright 2026 Exelerus AB
-Licensor Line of Business: provider-independent runtimes and coordination software for teams of AI agents

package/node_modules/@humwick/kernel/async-entity-persistence.ts

@@ -1,344 +0,0 @@
-import { Buffer } from "node:buffer";
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-import type { EntityListOptions, EntityPage, EntityStore, EntityStores, ModuleDefinition, ModuleManifest, Scope } from "./contract";
-import type { KernelEntityMutation, KernelEntityStoredRow, KernelPersistence, KernelStoredValue } from "./kernel-persistence";
-import { assertValidManifest } from "./manifest-validation";
-import {
-  EntityConflictError,
-  EntityNotFoundError,
-  EntitySessionClosedError,
-  type EntityRawListOptions,
-  type EntityRawPage,
-  type EntityRawRow,
-} from "./persistence";
-import {
-  buildModuleEntityCatalog,
-  decodeField,
-  encodeField,
-  entityCatalogOf,
-  type EntityField,
-  type EntityTable,
-} from "./persistence-schema";
-
-type EntityValue = Record<string, unknown>;
-
-interface RowState {
-  readonly table: EntityTable;
-  readonly key: unknown;
-  readonly expectedVersion: number | null;
-  value?: EntityValue;
-  deleted?: boolean;
-  mutation?: "put" | "delete";
-}
-
-function keyIdentity(table: EntityTable, key: unknown): string {
-  const encoded = encodeField(table.key, key);
-  const parts = [table.name, typeof encoded, String(encoded)];
-  return parts.map((part) => `${part.length}:${part}`).join("");
-}
-
-function decodedValue(table: EntityTable, row: KernelEntityStoredRow): EntityValue {
-  const value: EntityValue = {};
-  for (const field of table.fields) {
-    const decoded = decodeField(field, row.values[field.name]);
-    if (decoded !== undefined) value[field.name] = decoded;
-  }
-  return table.decl.schema.parse(value) as EntityValue;
-}
-
-function sign(secret: Buffer, body: string): string {
-  return createHmac("sha256", secret).update(body).digest("base64url");
-}
-
-function encodeCursor(secret: Buffer, table: EntityTable, scope: Scope, key: KernelStoredValue): string {
-  const body = Buffer.from(JSON.stringify({ v: 3, module: table.moduleId, entity: table.entityName, scope, type: typeof key, key: typeof key === "bigint" ? key.toString() : key })).toString("base64url");
-  return `${body}.${sign(secret, body)}`;
-}
-
-function decodeCursor(secret: Buffer, table: EntityTable, scope: Scope, cursor: string): KernelStoredValue {
-  try {
-    const split = cursor.lastIndexOf(".");
-    if (split < 0) throw new Error();
-    const body = cursor.slice(0, split);
-    const actual = Buffer.from(cursor.slice(split + 1));
-    const expected = Buffer.from(sign(secret, body));
-    if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) throw new Error();
-    const value = JSON.parse(Buffer.from(body, "base64url").toString("utf8")) as { v: number; module: string; entity: string; scope: string; type: string; key: KernelStoredValue };
-    if (value.v !== 3 || value.module !== table.moduleId || value.entity !== table.entityName || value.scope !== scope) throw new Error();
-    if (value.type === "bigint") return BigInt(value.key as string);
-    if (value.type !== typeof value.key) throw new Error();
-    return value.key;
-  } catch {
-    throw new TypeError(`invalid cursor for entity '${table.moduleId}.${table.entityName}'`);
-  }
-}
-
-function pageSize(limit: number | undefined): number {
-  const resolved = limit ?? 50;
-  if (!Number.isInteger(resolved) || resolved < 1 || resolved > 200) {
-    throw new RangeError("entity page limit must be an integer from 1 to 200");
-  }
-  return resolved;
-}
-
-function compareKeys(table: EntityTable, left: unknown, right: unknown): number {
-  const a = encodeField(table.key, left);
-  const b = encodeField(table.key, right);
-  return a === b ? 0 : a! < b! ? -1 : 1;
-}
-
-function matchesWhere(value: EntityValue, where: ReadonlyMap<EntityField, unknown>): boolean {
-  for (const [field, expected] of where) {
-    if (encodeField(field, value[field.name]) !== encodeField(field, expected)) return false;
-  }
-  return true;
-}
-
-export interface AsyncEntitySession<E> {
-  readonly entities: EntityStores<E>;
-  readonly pendingMutations: number;
-  seal(): void;
-  discard(): void;
-  mutations(): readonly KernelEntityMutation[];
-}
-
-class AsyncEntitySessionRuntime<E> implements AsyncEntitySession<E> {
-  readonly entities: EntityStores<E>;
-  readonly #states = new Map<string, RowState>();
-  #closed = false;
-  #finished = false;
-
-  constructor(
-    readonly port: KernelPersistence,
-    readonly ready: Promise<void>,
-    readonly scope: Scope,
-    readonly cursorSecret: Buffer,
-    tables: ReadonlyMap<string, EntityTable>,
-  ) {
-    this.entities = Object.freeze(Object.fromEntries(
-      [...tables].map(([name, table]) => [name, this.#store(table)]),
-    )) as EntityStores<E>;
-  }
-
-  get pendingMutations(): number {
-    return [...this.#states.values()].filter((state) => state.mutation !== undefined).length;
-  }
-
-  #assertOpen(): void {
-    if (this.#closed) throw new EntitySessionClosedError();
-  }
-
-  async #read(table: EntityTable, key: unknown): Promise<RowState> {
-    const identity = keyIdentity(table, key);
-    const known = this.#states.get(identity);
-    if (known) return known;
-    await this.ready;
-    const row = await this.port.entityPoint({ entity: entityCatalogOf(table), scope: this.scope, key: encodeField(table.key, key) });
-    const state: RowState = { table, key, expectedVersion: row?.version ?? null, value: row ? decodedValue(table, row) : undefined };
-    this.#states.set(identity, state);
-    return state;
-  }
-
-  #remember(table: EntityTable, row: KernelEntityStoredRow): RowState {
-    const value = decodedValue(table, row);
-    const key = value[table.key.name];
-    const identity = keyIdentity(table, key);
-    const known = this.#states.get(identity);
-    if (known) return known;
-    const state: RowState = { table, key, expectedVersion: row.version, value };
-    this.#states.set(identity, state);
-    return state;
-  }
-
-  #store(table: EntityTable): EntityStore {
-    return {
-      get: async (key) => {
-        this.#assertOpen();
-        const state = await this.#read(table, key);
-        return state.deleted ? undefined : state.value;
-      },
-      list: async (options) => this.#list(table, options as EntityListOptions<EntityValue> | undefined),
-      create: async (input) => {
-        this.#assertOpen();
-        const value = table.decl.schema.parse(input) as EntityValue;
-        const key = value[table.key.name];
-        const state = await this.#read(table, key);
-        if (!state.deleted && state.value !== undefined) throw new EntityConflictError(table.moduleId, table.entityName, key);
-        state.value = value;
-        state.deleted = false;
-        state.mutation = "put";
-        return value;
-      },
-      update: async (key, patch) => {
-        this.#assertOpen();
-        const state = await this.#read(table, key);
-        if (state.deleted || !state.value) throw new EntityNotFoundError(table.moduleId, table.entityName, key);
-        const value = table.decl.schema.parse({ ...state.value, ...patch }) as EntityValue;
-        if (keyIdentity(table, value[table.key.name]) !== keyIdentity(table, key)) throw new TypeError(`entity key '${table.key.name}' cannot be changed`);
-        state.value = value;
-        state.mutation = "put";
-        return value;
-      },
-      delete: async (key) => {
-        this.#assertOpen();
-        const state = await this.#read(table, key);
-        if (state.deleted || !state.value) return false;
-        state.deleted = true;
-        state.value = undefined;
-        state.mutation = state.expectedVersion === null ? undefined : "delete";
-        return true;
-      },
-    } as EntityStore;
-  }
-
-  async #list(table: EntityTable, options: EntityListOptions<EntityValue> | undefined): Promise<EntityPage<EntityValue>> {
-    this.#assertOpen();
-    await this.ready;
-    const limit = pageSize(options?.limit);
-    const where: Record<string, KernelStoredValue> = {};
-    const parsedWhere = new Map<EntityField, unknown>();
-    for (const [name, raw] of Object.entries(options?.where ?? {})) {
-      const field = table.fieldByName.get(name);
-      if (!field) throw new TypeError(`unknown where field '${name}' on '${table.moduleId}.${table.entityName}'`);
-      const parsed = field.schema.parse(raw);
-      parsedWhere.set(field, parsed);
-      where[name] = encodeField(field, parsed);
-    }
-    const after = options?.cursor ? decodeCursor(this.cursorSecret, table, this.scope, options.cursor) : undefined;
-    const stagedCount = [...this.#states.values()].filter((state) => state.table === table && state.mutation).length;
-    const rows = await this.port.entityList({ entity: entityCatalogOf(table), scope: this.scope, where, ...(after !== undefined ? { after } : {}), limit: limit + stagedCount + 1 });
-    const candidates = new Map<string, EntityValue>();
-    for (const row of rows) {
-      const state = this.#remember(table, row);
-      if (!state.deleted && state.value && matchesWhere(state.value, parsedWhere)) candidates.set(keyIdentity(table, state.key), state.value);
-    }
-    for (const state of this.#states.values()) {
-      if (state.table !== table || state.deleted || !state.value || !matchesWhere(state.value, parsedWhere)) continue;
-      if (after !== undefined && compareKeys(table, state.key, decodeField(table.key, after)) <= 0) continue;
-      candidates.set(keyIdentity(table, state.key), state.value);
-    }
-    const sorted = [...candidates.values()].sort((a, b) => compareKeys(table, a[table.key.name], b[table.key.name]));
-    const page = sorted.slice(0, limit);
-    const last = page.at(-1);
-    return {
-      items: page,
-      ...(sorted.length > limit && last ? { cursor: encodeCursor(this.cursorSecret, table, this.scope, encodeField(table.key, last[table.key.name])) } : {}),
-    };
-  }
-
-  seal(): void {
-    if (this.#finished) throw new EntitySessionClosedError();
-    this.#closed = true;
-  }
-
-  mutations(): readonly KernelEntityMutation[] {
-    if (!this.#closed || this.#finished) throw new EntitySessionClosedError();
-    const result: KernelEntityMutation[] = [];
-    for (const state of this.#states.values()) {
-      if (!state.mutation) continue;
-      const entity = entityCatalogOf(state.table);
-      if (state.mutation === "delete") {
-        result.push({ kind: "delete", entity, scope: this.scope, key: encodeField(state.table.key, state.key), logicalKey: state.key as string | number | bigint | boolean, expectedVersion: state.expectedVersion });
-      } else {
-        const values = Object.fromEntries(state.table.fields.map((field) => [field.name, encodeField(field, state.value![field.name])]));
-        result.push({ kind: "put", entity, scope: this.scope, key: encodeField(state.table.key, state.key), logicalKey: state.key as string | number | bigint | boolean, expectedVersion: state.expectedVersion, values });
-      }
-    }
-    this.#finished = true;
-    return Object.freeze(result);
-  }
-
-  discard(): void {
-    if (this.#finished) throw new EntitySessionClosedError();
-    this.#closed = true;
-    this.#states.clear();
-    this.#finished = true;
-  }
-}
-
-export class AsyncEntityPersistence {
-  readonly #tables = new Map<string, ReadonlyMap<string, EntityTable>>();
-  readonly #ready = new Map<string, Promise<void>>();
-  readonly #cursorSecret = randomBytes(32);
-
-  constructor(readonly port: KernelPersistence) {}
-
-  register<M extends ModuleManifest>(module: ModuleDefinition<M>): Promise<void> {
-    assertValidManifest(module);
-    if (this.#tables.has(module.id)) throw new Error(`module '${module.id}' entity persistence is already installed`);
-    const { catalog, tables } = buildModuleEntityCatalog(module);
-    this.#tables.set(module.id, tables);
-    const ready = this.port.installModule(structuredClone(catalog));
-    this.#ready.set(module.id, ready);
-    return ready;
-  }
-
-  begin<M extends ModuleManifest>(module: ModuleDefinition<M>, scope: Scope): AsyncEntitySession<M["entities"]> {
-    const tables = this.#tables.get(module.id);
-    const ready = this.#ready.get(module.id);
-    if (!tables || !ready) throw new Error(`module '${module.id}' entity persistence is not installed`);
-    return new AsyncEntitySessionRuntime(this.port, ready, scope, this.#cursorSecret, tables);
-  }
-
-  ready(moduleId: string): Promise<void> {
-    const ready = this.#ready.get(moduleId);
-    if (!ready) throw new Error(`module '${moduleId}' entity persistence is not installed`);
-    return ready;
-  }
-
-  #lookupTable(moduleId: string, entityName: string): EntityTable | undefined {
-    return this.#tables.get(moduleId)?.get(entityName);
-  }
-
-  #rawRow(table: EntityTable, scope: Scope, row: KernelEntityStoredRow): EntityRawRow {
-    const fields = decodedValue(table, row);
-    return {
-      module: table.moduleId,
-      entity: table.entityName,
-      scope,
-      key: fields[table.key.name],
-      version: row.version,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      fields,
-    };
-  }
-
-  async readEntity(moduleId: string, entityName: string, scope: Scope, key: unknown): Promise<EntityRawRow | undefined> {
-    const table = this.#lookupTable(moduleId, entityName);
-    if (!table) return undefined;
-    await this.ready(moduleId);
-    const parsedKey = table.key.schema.parse(key);
-    const row = await this.port.entityPoint({ entity: entityCatalogOf(table), scope, key: encodeField(table.key, parsedKey) });
-    return row ? this.#rawRow(table, scope, row) : undefined;
-  }
-
-  async listEntity(moduleId: string, entityName: string, scope: Scope, options: EntityRawListOptions = {}): Promise<EntityRawPage> {
-    const table = this.#lookupTable(moduleId, entityName);
-    if (!table) return { items: [] };
-    await this.ready(moduleId);
-    const limit = pageSize(options.limit);
-    const where: Record<string, KernelStoredValue> = {};
-    for (const [name, raw] of Object.entries(options.where ?? {})) {
-      const field = table.fieldByName.get(name);
-      if (!field) throw new TypeError(`unknown where field '${name}' on '${moduleId}.${entityName}'`);
-      where[name] = encodeField(field, field.schema.parse(raw));
-    }
-    const after = options.cursor ? decodeCursor(this.#cursorSecret, table, scope, options.cursor) : undefined;
-    const rows = await this.port.entityList({
-      entity: entityCatalogOf(table),
-      scope,
-      where,
-      ...(after !== undefined ? { after } : {}),
-      limit: limit + 1,
-    });
-    const items = rows.slice(0, limit).map((row) => this.#rawRow(table, scope, row));
-    const last = items.at(-1);
-    return {
-      items,
-      ...(rows.length > limit && last
-        ? { cursor: encodeCursor(this.#cursorSecret, table, scope, encodeField(table.key, last.key)) }
-        : {}),
-    };
-  }
-}

package/node_modules/@humwick/kernel/async-event-log.ts

@@ -1,107 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import type * as z from "zod";
-import type { EventWriter, ModuleDefinition, ModuleManifest, Scope } from "./contract";
-import { EventSessionClosedError, EventTopicMismatchError, UndeclaredEventError } from "./event-log";
-import type { KernelEventAppend, KernelPersistence } from "./kernel-persistence";
-
-interface PendingEvent {
-  readonly name: string;
-  readonly payload: string;
-}
-
-function normalizeJsonSafe(value: unknown): unknown {
-  if (typeof value === "number") return Object.is(value, -0) ? 0 : value;
-  if (Array.isArray(value)) return value.map(normalizeJsonSafe);
-  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, normalizeJsonSafe(entry)]));
-  }
-  return value;
-}
-
-function encodePayload(value: unknown, name: string): string {
-  try {
-    const encoded = JSON.stringify(value);
-    if (encoded === undefined || !isDeepStrictEqual(JSON.parse(encoded) as unknown, normalizeJsonSafe(value))) {
-      throw new TypeError("value changes during JSON encoding");
-    }
-    return encoded;
-  } catch (error) {
-    throw new TypeError(`event '${name}' payload must be JSON-safe: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export interface AsyncEventSession<E> {
-  readonly events: EventWriter<E>;
-  readonly pendingEvents: number;
-  seal(): void;
-  discard(): void;
-  appends(createdAt: number): readonly KernelEventAppend[];
-}
-
-class AsyncEventSessionRuntime<E> implements AsyncEventSession<E> {
-  readonly events: EventWriter<E>;
-  readonly #buffer: PendingEvent[] = [];
-  #closed = false;
-  #finished = false;
-
-  constructor(readonly scope: Scope, readonly moduleId: string, readonly schemas: ReadonlyMap<string, z.ZodType>) {
-    const prefix = `${moduleId}.`;
-    this.events = {
-      emit: async (name: string, payload: unknown) => {
-        if (this.#closed) throw new EventSessionClosedError();
-        if (!name.startsWith(prefix) || name.length === prefix.length) throw new EventTopicMismatchError(moduleId, name);
-        const schema = schemas.get(name);
-        if (!schema) throw new UndeclaredEventError(moduleId, name);
-        this.#buffer.push({ name, payload: encodePayload(schema.parse(payload), name) });
-      },
-    } as unknown as EventWriter<E>;
-  }
-
-  get pendingEvents(): number { return this.#buffer.length; }
-
-  seal(): void {
-    if (this.#finished) throw new EventSessionClosedError();
-    this.#closed = true;
-  }
-
-  appends(createdAt: number): readonly KernelEventAppend[] {
-    if (!this.#closed || this.#finished) throw new EventSessionClosedError();
-    this.#finished = true;
-    return Object.freeze(this.#buffer.map((event) => Object.freeze({
-      scope: this.scope,
-      moduleId: this.moduleId,
-      name: event.name,
-      payload: event.payload,
-      createdAt,
-    })));
-  }
-
-  discard(): void {
-    if (this.#finished) throw new EventSessionClosedError();
-    this.#closed = true;
-    this.#buffer.length = 0;
-    this.#finished = true;
-  }
-}
-
-export class AsyncEventLogPersistence {
-  readonly #modules = new Map<string, ReadonlyMap<string, z.ZodType>>();
-  constructor(readonly port: KernelPersistence) {}
-
-  register<M extends ModuleManifest>(module: ModuleDefinition<M>): void {
-    if (this.#modules.has(module.id)) throw new Error(`module '${module.id}' event log is already installed`);
-    this.#modules.set(module.id, new Map(Object.entries(module.events ?? {}) as Array<[string, z.ZodType]>));
-  }
-
-  begin<M extends ModuleManifest>(module: ModuleDefinition<M>, scope: Scope): AsyncEventSession<NonNullable<M["events"]>> {
-    const schemas = this.#modules.get(module.id);
-    if (!schemas) throw new Error(`module '${module.id}' event log is not installed`);
-    return new AsyncEventSessionRuntime(scope, module.id, schemas);
-  }
-
-  replay(scope: Scope, since: number, limit: number, moduleId?: string) {
-    return this.port.replayEvents(scope, since, limit, moduleId);
-  }
-
-  highWater(scope: Scope) { return this.port.eventHighWater(scope); }
-}