@wovin/core 0.0.0-ciao-mobx-955482e8

package/dist/thread/filters.d.ts

@@ -0,0 +1,47 @@
+import { Applog, ApplogForInsert, DatalogQueryPattern } from '../applog/datom-types.ts';
+import type { Subscribable } from '../query/subscribable.ts';
+import { Thread, ThreadEvent } from './basic.ts';
+import { ApplogEventMapper, MappedThread } from './mapped.ts';
+export declare const rollingFilter: (thread: Thread, pattern: DatalogQueryPattern, opts?: {
+    name?: string;
+    extraFilterName?: string;
+}) => MappedThread;
+export declare const rollingMapper: (thread: Thread, eventMapper: ApplogEventMapper, opts?: {
+    name?: string;
+    extraFilterName?: string;
+}) => MappedThread;
+export declare const rollingAcc: <ACC>(thread: Thread, acc: ACC, eventMapper: (event: ThreadEvent, acc: ACC) => void, opts?: {
+    name?: string;
+}) => Subscribable<ACC>;
+export declare const getUntrackedPattern: (pattern: DatalogQueryPattern) => Partial<import("../applog.ts").WithMatchers<Applog>>;
+export declare function makeFilter(pattern: DatalogQueryPattern): (logs: readonly Applog[]) => Applog[];
+/**
+ * // ! think twice before using
+ */
+export declare const getUntrackedFilterResults: (thread: Thread, pattern: DatalogQueryPattern, opts?: {
+    name?: string;
+}) => Applog[];
+export type ThreadWithFilter<T extends string> = Thread & {
+    filters: readonly T[];
+};
+export declare function hasFilter<T extends string>(thread: Thread, filter: T): thread is ThreadWithFilter<T>;
+export declare function assertRaw(thread: Thread): ThreadWithoutFilters;
+export declare function assertOnlyCurrent(thread: Thread): Thread & {
+    filters: readonly "lastWriteWins"[];
+} & {
+    filters: readonly "withoutDeleted"[];
+};
+export type ThreadOnlyCurrent = ThreadWithFilter<'lastWriteWins'>;
+export type ThreadNoDeleted = ThreadWithFilter<'withoutDeleted'>;
+export type ThreadOnlyCurrentNoDeleted = ThreadWithFilter<'lastWriteWins' | 'withoutDeleted'>;
+export type ThreadWithoutFilters = Thread & {
+    filters: [];
+};
+/** Re-export for convenience */
+export declare const asReadOnly: typeof MappedThread.asReadOnly;
+export type ApplogMapper = (log: Applog, sourceThread: Thread) => ApplogForInsert;
+export declare const simpleApplogMapper: (thread: Thread, logMapper: ApplogMapper, opts?: {
+    name?: string;
+    extraFilterName?: string;
+}) => MappedThread;
+//# sourceMappingURL=filters.d.ts.map

package/dist/thread/filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/thread/filters.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,eAAe,EAA0B,mBAAmB,EAAkB,MAAM,0BAA0B,CAAA;AAI/H,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAe,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI7D,eAAO,MAAM,aAAa,WACjB,MAAM,WACL,mBAAmB,SACtB;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,iBAoChD,CAAA;AAEF,eAAO,MAAM,aAAa,WACjB,MAAM,eACD,iBAAiB,SACxB;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAE,iBAkBhD,CAAA;AAEF,eAAO,MAAM,UAAU,GAEF,GAAG,UACd,MAAM,OACT,GAAG,eACK,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,KAAK,IAAI,SAC7C;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACrB,YAAY,CAAC,GAAG,CAcnB,CAAA;AAED,eAAO,MAAM,mBAAmB,GAC/B,SAAS,mBAAmB,yDAM5B,CAAA;AACD,wBAAgB,UAAU,CACzB,OAAO,EAAE,mBAAmB,IAED,MAAM,SAAS,MAAM,EAAE,cAclD;AAED;;GAEG;AACH,eAAO,MAAM,yBAAyB,GACrC,QAAQ,MAAM,EACd,SAAS,mBAAmB,EAC5B,OAAM;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,aAK5B,CAAA;AAKD,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,GAAG;IACzD,OAAO,EAAE,SAAS,CAAC,EAAE,CAAA;CACrB,CAAA;AACD,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAEpG;AACD,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAItB,oBAAoB,CACrC;AACD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM;;;;EAM/C;AACD,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAA;AACjE,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,CAAA;AAChE,MAAM,MAAM,0BAA0B,GAAG,gBAAgB,CAAC,eAAe,GAAG,gBAAgB,CAAC,CAAA;AAC7F,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,EAAE,CAAA;CAAE,CAAA;AAE3D,gCAAgC;AAChC,eAAO,MAAM,UAAU,gCAA0B,CAAA;AAMjD,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,eAAe,CAAA;AACjF,eAAO,MAAM,kBAAkB,GAC9B,QAAQ,MAAM,EACd,WAAW,YAAY,EACvB,OAAM;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAO,iBAsDtD,CAAA"}

package/dist/thread/mapped.d.ts

@@ -0,0 +1,31 @@
+import { Applog, ApplogForInsert } from '../applog/datom-types.ts';
+import { Thread, ThreadEvent } from './basic.ts';
+export type ApplogEventMapper = (this: MappedThread, event: ThreadEvent, sourceThread: Thread) => ThreadEvent;
+export type ApplogWriteMapper = (this: MappedThread, applogs: Applog[] | ApplogForInsert[]) => Applog[] | ApplogForInsert[] | null;
+export declare class MappedThread extends Thread {
+    readonly name: string;
+    readonly _initialLogs: Applog[];
+    private _eventMapper;
+    private _writeMapper;
+    private _readOnly?;
+    static mapWrites(parent: Thread, name: string, mapper: ApplogWriteMapper): MappedThread;
+    static asReadOnly(parent: Thread): Thread;
+    private _parentSubscriptions;
+    constructor(name: string, parents: Thread | readonly Thread[], filters: readonly string[], _initialLogs: Applog[], _eventMapper: ApplogEventMapper | null, _writeMapper?: ApplogWriteMapper, _readOnly?: boolean);
+    insert(appLogsToInsert: ApplogForInsert[]): void;
+    insertRaw(appLogsToInsert: Applog[]): void;
+    private subscribeToParents;
+    /** Tear down parent subscriptions and clear internal state */
+    dispose(): void;
+    /** Swap parents at runtime — re-subscribes and recomputes applogs, notifying downstream */
+    setParents(newParents: readonly Thread[]): void;
+    subscribe(callback: (event: ThreadEvent) => void, type?: 'derived' | 'reaction'): () => void;
+    /**
+     * // HACK to trigger remap on pattern change in rollingFilter
+     * should not be used lightly
+     */
+    triggerRemap(): void;
+    protected onParentUpdate(thread: Thread, event: ThreadEvent): void;
+    get readOnly(): boolean;
+}
+//# sourceMappingURL=mapped.d.ts.map

package/dist/thread/mapped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapped.d.ts","sourceRoot":"","sources":["../../src/thread/mapped.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAClE,OAAO,EAAe,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAI7D,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,KAAK,WAAW,CAAA;AAE7G,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,eAAe,EAAE,KAAK,MAAM,EAAE,GAAG,eAAe,EAAE,GAAG,IAAI,CAAA;AAElI,qBAAa,YAAa,SAAQ,MAAM;IA4BtC,QAAQ,CAAC,IAAI,EAAE,MAAM;IAGrB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE;IAC/B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,SAAS,CAAC;IAjCnB,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB;IAWxE,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM;IAahC,OAAO,CAAC,oBAAoB,CAAkC;gBAGpD,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACnC,OAAO,EAAE,SAAS,MAAM,EAAE,EACjB,YAAY,EAAE,MAAM,EAAE,EACvB,YAAY,EAAE,iBAAiB,GAAG,IAAI,EACtC,YAAY,GAAE,iBAAwB,EACtC,SAAS,CAAC,EAAE,OAAO;IAgBrB,MAAM,CAAC,eAAe,EAAE,eAAe,EAAE;IAMzC,SAAS,CAAC,eAAe,EAAE,MAAM,EAAE;IAO1C,OAAO,CAAC,kBAAkB;IAe1B,8DAA8D;IAC9D,OAAO;IASP,2FAA2F;IAC3F,UAAU,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE;IAOxC,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,UAAU;IAO/E;;;OAGG;IACH,YAAY;IAWZ,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW;IAiC3D,IAAI,QAAQ,YAEX;CACD"}

package/dist/thread/utils.d.ts

@@ -0,0 +1,23 @@
+import { CID } from 'multiformats';
+import { compareApplogsByEnAt } from '../applog/applog-utils.ts';
+import { Applog, ApplogForInsert, CidString } from '../applog/datom-types.ts';
+import { Thread } from './basic.ts';
+import { MappedThread } from './mapped.ts';
+export declare function entityCount(thread: Thread): number;
+export declare function allEntityIDs(thread: Thread): Set<string>;
+export declare function debounceWrites(thread: Thread, wait?: number, removeDuplicatesWith?: (objA: object, objB: object) => boolean): MappedThread;
+/**
+ * @param deduplicateHoldItemsWith called with (heldLog, realLog), if it returns true, the held log is skipped
+ * @param onFirstWrite called with held logs about to be inserted, if it returns an array, those logs will be inserted instead
+ */
+export declare function holdTillFirstWrite(thread: Thread, applogsToHold: ApplogForInsert[], opts: {
+    deduplicateHoldItemsWith?: typeof compareApplogsByEnAt;
+    onFirstWrite: (heldLogsToInsert: Applog[]) => Applog[] | undefined;
+}): MappedThread;
+export declare function getAgents(thread: Thread): import("../applog.ts").AgentHash[];
+/**
+ * Returns applogs NOT contained in the exclusion set.
+ * Uses CID-based comparison (consistent with removeDuplicateAppLogs).
+ */
+export declare const excludeApplogsContainedIn: (applogs: readonly Applog[], exclude: Thread | readonly Applog[] | Set<CID | CidString>) => Applog[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/thread/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/thread/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAElC,OAAO,EAAE,oBAAoB,EAAsC,MAAM,2BAA2B,CAAA;AACpG,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAY,MAAM,0BAA0B,CAAA;AACvF,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,UAEzC;AACD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,eAE1C;AAcD,wBAAgB,cAAc,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,SAAM,EACV,oBAAoB,0CAAuB,gBA4B3C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,eAAe,EAAE,EAChC,IAAI,EAAE;IACL,wBAAwB,CAAC,EAAE,OAAO,oBAAoB,CAAA;IACtD,YAAY,EAAE,CAAC,gBAAgB,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS,CAAA;CAClE,gBA2CD;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,sCAEvC;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GACrC,SAAS,SAAS,MAAM,EAAE,EAC1B,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC,GAAG,GAAG,SAAS,CAAC,KACxD,MAAM,EAcR,CAAA"}

package/dist/thread/writeable.d.ts

@@ -0,0 +1,41 @@
+import { type Applog, ApplogForInsert, CidString } from '../applog/datom-types.ts';
+import { Thread } from './basic.ts';
+export declare abstract class WriteableThread extends Thread {
+    constructor(name: string, applogs: Applog[], filters: readonly string[]);
+    purge(cidsToPurge: CidString[]): number;
+    insert(appLogsToInsert: ApplogForInsert[]): Applog[];
+    /**
+     * Insert only applogs not already in this thread.
+     * @param byRef If true, compares by reference; if false, compares by CID (default)
+     * @returns The applogs that were actually inserted
+     */
+    insertMissing(appLogsToInsert: readonly Applog[], byRef?: boolean): Applog[];
+    /**
+     * Insert raw applogs directly into the thread.
+     *
+     * STRICT VALIDATION: This method throws errors for:
+     * - Duplicate applogs in input array (programming error)
+     * - Invalid applogs (missing required fields)
+     * - Applogs already in thread (programming error)
+     *
+     * For external imports where duplicates are expected, use removeDuplicateAppLogs(..., 'cleanup')
+     * before calling this method.
+     *
+     * @param appLogsToInsert Must be deduplicated and validated. Needs to be mutable because it will be sorted
+     * 	(and if you need to clone it, so do it when you need to) - this is weird as TS is slathering type safety onto ducks
+     * @throws Error if validation fails
+     */
+    insertRaw(appLogsToInsert: Applog[]): Applog[];
+    get readOnly(): boolean;
+    protected abstract persist(logs: Applog[]): Promise<void>;
+}
+export declare class ThreadInMemory extends WriteableThread {
+    readonly _readOnly: boolean;
+    static empty(name?: string): ThreadInMemory;
+    static fromArray(applogs: Applog[], name?: string, readOnly?: boolean): ThreadInMemory;
+    static fromReadOnlyArray(applogs: readonly Applog[], name?: string): ThreadInMemory;
+    constructor(name: string, applogs: Applog[], filters: readonly string[], _readOnly: boolean);
+    get readOnly(): boolean;
+    protected persist(logs: Applog[]): Promise<void>;
+}
+//# sourceMappingURL=writeable.d.ts.map

package/dist/thread/writeable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeable.d.ts","sourceRoot":"","sources":["../../src/thread/writeable.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,MAAM,EAAE,eAAe,EAAE,SAAS,EAAiB,MAAM,0BAA0B,CAAA;AACjG,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAInC,8BAAsB,eAAgB,SAAQ,MAAM;gBAElD,IAAI,EAAE,MAAM,EAEZ,OAAO,EAAE,MAAM,EAAO,EACtB,OAAO,EAAE,SAAS,MAAM,EAAE;IAKpB,KAAK,CAAC,WAAW,EAAE,SAAS,EAAE;IAM9B,MAAM,CAAC,eAAe,EAAE,eAAe,EAAE;IAWhD;;;;OAIG;IACI,aAAa,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,UAAQ,GAAG,MAAM,EAAE;IASjF;;;;;;;;;;;;;;OAcG;IACI,SAAS,CAAC,eAAe,EAAE,MAAM,EAAE;IA6D1C,IAAI,QAAQ,YAEX;IAED,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CACzD;AACD,qBAAa,cAAe,SAAQ,eAAe;IAgBjD,QAAQ,CAAC,SAAS,EAAE,OAAO;IAf5B,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM;IAG1B,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAQ;IAGnE,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;gBAMjE,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,EACjB,SAAS,EAAE,OAAO;IAK5B,IAAI,QAAQ,YAEX;cAEe,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE;CAMtC"}

package/dist/thread.d.ts

@@ -0,0 +1,6 @@
+export * from './thread/basic.ts';
+export * from './thread/filters.ts';
+export * from './thread/mapped.ts';
+export * from './thread/writeable.ts';
+export * from './thread/utils.ts';
+//# sourceMappingURL=thread.d.ts.map

package/dist/thread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.d.ts","sourceRoot":"","sources":["../src/thread.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA"}

package/dist/thread.js

@@ -0,0 +1,54 @@
+import {
+  MappedThread,
+  StaticThread,
+  Thread,
+  ThreadInMemory,
+  WriteableThread,
+  allEntityIDs,
+  asReadOnly,
+  assertOnlyCurrent,
+  assertRaw,
+  debounceWrites,
+  entityCount,
+  excludeApplogsContainedIn,
+  getAgents,
+  getLogsFromThread,
+  getUntrackedFilterResults,
+  getUntrackedPattern,
+  hasFilter,
+  holdTillFirstWrite,
+  isInitEvent,
+  makeFilter,
+  rollingAcc,
+  rollingFilter,
+  rollingMapper,
+  simpleApplogMapper
+} from "./chunk-XIQSYEV3.js";
+import "./chunk-ZAADLBSB.js";
+export {
+  MappedThread,
+  StaticThread,
+  Thread,
+  ThreadInMemory,
+  WriteableThread,
+  allEntityIDs,
+  asReadOnly,
+  assertOnlyCurrent,
+  assertRaw,
+  debounceWrites,
+  entityCount,
+  excludeApplogsContainedIn,
+  getAgents,
+  getLogsFromThread,
+  getUntrackedFilterResults,
+  getUntrackedPattern,
+  hasFilter,
+  holdTillFirstWrite,
+  isInitEvent,
+  makeFilter,
+  rollingAcc,
+  rollingFilter,
+  rollingMapper,
+  simpleApplogMapper
+};
+//# sourceMappingURL=thread.js.map

package/dist/thread.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/types/typescript-utils.d.ts

@@ -0,0 +1,34 @@
+import { Type as T } from '@sinclair/typebox';
+declare const StringTB: (options?: import("@sinclair/typebox").StringOptions) => import("@sinclair/typebox").TString, OptionalTB: <T extends import("@sinclair/typebox").TSchema>(schema: T) => import("@sinclair/typebox").TOptional<T>, BooleanTB: (options?: import("@sinclair/typebox").SchemaOptions) => import("@sinclair/typebox").TBoolean, ObjectTB: <T extends import("@sinclair/typebox").TProperties>(properties: T, options?: import("@sinclair/typebox").ObjectOptions) => import("@sinclair/typebox").TObject<T>, NumberTB: (options?: import("@sinclair/typebox").NumericOptions<number>) => import("@sinclair/typebox").TNumber;
+export declare const Str: typeof StringTB;
+export declare const Num: typeof NumberTB;
+export declare const Obj: typeof ObjectTB;
+export declare const Opt: typeof OptionalTB;
+export declare const Bool: typeof BooleanTB;
+export declare const STR: ReturnType<typeof T.String>;
+export declare const NUM: ReturnType<typeof T.Number>;
+export declare const BOOL: ReturnType<typeof T.Boolean>;
+export type GenericObject = Record<string, any>;
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;
+export type CoerceToString<T> = T extends string ? T : never;
+/**
+ * Define nominal type of U based on type of T. Similar to Opaque types in Flow
+ */
+export type Tagged<T, Tag> = T & {
+    tag?: Tag;
+};
+export type LastElementOf<T extends readonly unknown[]> = T extends readonly [...unknown[], infer Last] ? Last : never;
+export declare function checkParityTB(): void;
+/** solidjs Setter requires returning something, which I often don't */
+export type GenericSetter<T> = (newValue: T) => void;
+export type ArrayOrSingle<T> = T | T[] | readonly T[];
+export declare function arrayIfSingle<T>(arrOrSingle: ArrayOrSingle<T>): readonly T[];
+export type ArrayType<T> = T extends (infer U)[] ? U : T;
+export type ArrayElementType<T> = T extends readonly (infer U)[] ? Extract<U, string> : never;
+export type ConstructorType<T, S = {}> = {
+    new (...args: any[]): T;
+} & S;
+export {};
+//# sourceMappingURL=typescript-utils.d.ts.map

package/dist/types/typescript-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-utils.d.ts","sourceRoot":"","sources":["../../src/types/typescript-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,CAAC,EAAE,MAAM,mBAAmB,CAAA;AAO7C,QAAA,MAAgB,QAAQ,gGAAY,UAAU,0GAAW,SAAS,iGAAU,QAAQ,qKAAU,QAAQ,uGAAM,CAAA;AAC5G,eAAO,MAAM,GAAG,EAAE,OAAO,QAA2B,CAAA;AACpD,eAAO,MAAM,GAAG,EAAE,OAAO,QAA2B,CAAA;AACpD,eAAO,MAAM,GAAG,EAAE,OAAO,QAA2B,CAAA;AACpD,eAAO,MAAM,GAAG,EAAE,OAAO,UAA+B,CAAA;AACxD,eAAO,MAAM,IAAI,EAAE,OAAO,SAA6B,CAAA;AAEvD,eAAO,MAAM,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAS,CAAA;AACrD,eAAO,MAAM,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAS,CAAA;AACrD,eAAO,MAAM,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAU,CAAA;AAExD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAC/C,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AACrE,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAC9E,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAExF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,CAAA;AAE5D;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,GAAG,CAAA;CAAE,CAAA;AAU9C,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS,CAAC,GAAG,OAAO,EAAE,EAAE,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,CAAA;AAEtH,wBAAgB,aAAa,SAS5B;AAED,uEAAuE;AACvE,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,IAAI,CAAA;AAEpD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAAA;AACrD,wBAAgB,aAAa,CAAC,CAAC,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAG5E;AACD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;AACxD,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,KAAK,CAAA;AAC7F,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI;IACxC,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CACtB,GAAG,CAAC,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export * from './types/typescript-utils.ts';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA"}

package/dist/types.js

@@ -0,0 +1,26 @@
+import "./chunk-E46VTKTZ.js";
+import {
+  BOOL,
+  Bool,
+  NUM,
+  Num,
+  Obj,
+  Opt,
+  STR,
+  Str,
+  arrayIfSingle,
+  checkParityTB
+} from "./chunk-ZAADLBSB.js";
+export {
+  BOOL,
+  Bool,
+  NUM,
+  Num,
+  Obj,
+  Opt,
+  STR,
+  Str,
+  arrayIfSingle,
+  checkParityTB
+};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utils/debug-name.d.ts

@@ -0,0 +1,13 @@
+import type { Applog, DatalogQueryPattern } from '../applog/datom-types.ts';
+import type { Thread } from '../thread/basic.ts';
+export declare const createDebugName: ({ caller, thread, pattern, args }: {
+    caller?: string;
+    thread?: Thread | Applog[];
+    pattern?: DatalogQueryPattern | DatalogQueryPattern[] | string;
+    args?: any;
+}) => string;
+export declare const createDebugNameObj: (args: Parameters<typeof createDebugName>[0]) => {
+    readonly name: string;
+};
+export declare function prettifyThreadName(input: string): string;
+//# sourceMappingURL=debug-name.d.ts.map

package/dist/utils/debug-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-name.d.ts","sourceRoot":"","sources":["../../src/utils/debug-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAO,MAAM,eAAe,GAAI,mCAAmC;IAClE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC1B,OAAO,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,EAAE,GAAG,MAAM,CAAA;IAC9D,IAAI,CAAC,EAAE,GAAG,CAAA;CACV,WAMA,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAM,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC;;CAE7E,CAAA;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgCxD"}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import { Applog, ApplogEncNoCid } from './applog/datom-types.ts';
+export declare const isTruthy: (l: Applog | ApplogEncNoCid) => boolean;
+export declare const keepTruthy: (arr: readonly any[]) => any[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAEhE,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,GAAG,cAAc,KAAG,OAAc,CAAA;AACpE,eAAO,MAAM,UAAU,GAAI,KAAK,SAAS,GAAG,EAAE,KAAG,GAAG,EAA0B,CAAA"}

package/dist/utils.js

@@ -0,0 +1,9 @@
+import {
+  isTruthy,
+  keepTruthy
+} from "./chunk-YDAKBU6Q.js";
+export {
+  isTruthy,
+  keepTruthy
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@wovin/core",
+  "version": "0.0.0-ciao-mobx-955482e8",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "browser": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./applog": {
+      "import": "./dist/applog.js",
+      "types": "./dist/applog.d.ts"
+    },
+    "./blockstore": {
+      "import": "./dist/blockstore.js",
+      "types": "./dist/blockstore.d.ts"
+    },
+    "./ipfs": {
+      "import": "./dist/ipfs.js",
+      "types": "./dist/ipfs.d.ts"
+    },
+    "./pubsub": {
+      "import": "./dist/pubsub.js",
+      "types": "./dist/pubsub.d.ts"
+    },
+    "./query": {
+      "import": "./dist/query.js",
+      "types": "./dist/query.d.ts"
+    },
+    "./retrieve": {
+      "import": "./dist/retrieve.js",
+      "types": "./dist/retrieve.d.ts"
+    },
+    "./thread": {
+      "import": "./dist/thread.js",
+      "types": "./dist/thread.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils.js",
+      "types": "./dist/utils.d.ts"
+    },
+    "./ipns": {
+      "import": "./dist/ipns.js",
+      "types": "./dist/ipns.d.ts"
+    }
+  },
+  "files": [
+    "./dist/",
+    "./src/"
+  ],
+  "packageManager": "pnpm",
+  "esm.sh": {
+    "bundle": false
+  },
+  "peerDependencies": {
+    "@sinclair/typebox": "^0.31.28"
+  },
+  "dependencies": {
+    "@ipld/car": "^5.4.2",
+    "@ipld/dag-json": "^10.2.5",
+    "@noble/hashes": "^2.0.1",
+    "@oddjs/odd": "^0.37.2",
+    "besonders-logger": "1.0.2",
+    "date-fns": "^3.3.1",
+    "hash-wasm": "^4.12.0",
+    "iso-kv": "^3.1.1",
+    "iso-signatures": "^0.5.1",
+    "iso-ucan": "^0.4.2",
+    "lodash-es": "^4.17.21",
+    "@libp2p/crypto": "^5.0.0",
+    "ipns": "^10.1.2",
+    "multiformats": "^13.4.1",
+    "safe-stable-stringify": "^2.5.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "concurrently": "^8.2.2",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.7",
+    "tsupconfig": "^0.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/wovin/wovin.git",
+    "directory": "packages/@wovin/core"
+  },
+  "license": "AGPL-3.0-or-later",
+  "scripts": {
+    "build": "rm -rf dist/ && concurrently \"pnpm build:code\" \"pnpm build:types\"",
+    "build:code": "tsup --external esbuild",
+    "build:types": "tsc --emitDeclarationOnly --declaration",
+    "dev": "concurrently \"pnpm dev:code\" \"pnpm dev:types\"",
+    "dev:code": "tsup --watch",
+    "dev:types": "tsc --emitDeclarationOnly --declaration --watch",
+    "lint": "eslint .",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "pub": "npm publish --tag latest --access=public"
+  }
+}

package/src/applog/applog-helpers.ts

@@ -0,0 +1,150 @@
+import { Logger } from 'besonders-logger'
+import { encodeApplogAndGetCid } from '../ipfs/ipfs-utils.ts'
+import { lastWriteWins } from '../query/basic.ts'
+import { ApplogEventMapper, isInitEvent, MappedThread, rollingFilter, Thread, ThreadOnlyCurrent } from '../thread.ts'
+import { PartialBy } from '../types/typescript-utils.ts'
+import { dateNowIso, objEqualByKeys, removeDuplicateAppLogs, sortApplogsByTs } from './applog-utils.ts'
+import {
+	Applog,
+	ApplogForInsert,
+	ApplogForInsertOptionalAgent,
+	ApplogNoCid,
+	AgentHash,
+	CidString,
+	getApplogTypeErrors,
+	isValidApplog,
+	Timestamp,
+} from './datom-types.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
+
+export function ensureTsPvAndFinalizeApplogs(appLogsToInsert: ApplogForInsert[], threadForPv: Thread) {
+	DEBUG(`[ensureTsPvAndFinalizeApplogs] ENTER - ${appLogsToInsert.length} applogs, thread size=${threadForPv.size}`)
+	const ts = dateNowIso()
+	// const currentThread = lastWriteWins(threadForPv, { tolerateAlreadyFiltered: true }) // HACK to get `pv` from last write
+	const currentThread = threadForPv // HACK to not do un-cached lastWriteWins
+
+	DEBUG(`[ensureTsPvAndFinalizeApplogs] About to map over applogs`)
+	const mapped = appLogsToInsert.map((log, idx) => {
+		DEBUG(`[ensureTsPvAndFinalizeApplogs] Processing applog ${idx + 1}/${appLogsToInsert.length}`)
+		const result = finalizeApplogForInsert(log, { ts, threadForPv: currentThread })
+		DEBUG(`[ensureTsPvAndFinalizeApplogs] Finalized applog ${idx + 1}/${appLogsToInsert.length}`)
+		return result
+	})
+	DEBUG(`[ensureTsPvAndFinalizeApplogs] EXIT - mapped ${mapped.length} applogs`)
+	return mapped
+}
+export function ensureTsPvAndFinalizeApplog(applogToInsert: ApplogForInsert, threadForPv: Thread) {
+	return ensureTsPvAndFinalizeApplogs([applogToInsert], threadForPv)[0]
+}
+
+export function finalizeApplogForInsert(
+	log: ApplogForInsert,
+	{ ts, threadForPv }: { ts?: string; threadForPv?: Thread /*OnlyCurrent*/ } = {},
+) {
+	DEBUG(`[finalizeApplogForInsert] ENTER - en=${log.en}, at=${log.at}`)
+	DEBUG(`[finalizeApplogForInsert] About to call withTs`)
+	const logWithTs = withTs(log, ts ?? dateNowIso())
+	DEBUG(`[finalizeApplogForInsert] About to call withPvFrom (thread size=${threadForPv?.size ?? 'null'})`)
+	const logWithPv = withPvFrom(logWithTs, threadForPv)
+	DEBUG(`[finalizeApplogForInsert] About to call encodeApplogAndGetCid`)
+	const cid = encodeApplogAndGetCid(logWithPv).toString() as CidString
+	DEBUG(`[finalizeApplogForInsert] CID created: ${cid}`)
+	if ((log as Applog).cid && (log as Applog).cid !== cid) WARN(`[finalizeApplogForInsert] overwriting wrong CID`, { log, cid, logWithPv })
+	const logWithCid = { ...logWithPv, cid } satisfies Applog
+	DEBUG(`[finalizeApplogForInsert] About to validate applog`)
+	if (!isValidApplog(logWithCid)) {
+		throw ERROR(`Bogus Applog ${JSON.stringify(logWithCid)}`, getApplogTypeErrors(logWithCid))
+	}
+	DEBUG(`[finalizeApplogForInsert] EXIT - CID=${cid}`)
+	return Object.freeze(logWithCid)
+}
+
+export function hasAg(log: ApplogForInsertOptionalAgent): log is ApplogForInsert {
+	return !!log.ag
+}
+export function hasTs(log: ApplogForInsert): log is Omit<ApplogForInsert, 'ts'> & { ts: Timestamp } {
+	return !!log.ts
+}
+export function hasPv(log: ApplogForInsert): log is ApplogForInsert & { pv: string } {
+	return !!log.pv
+}
+
+export function withTs(log: ApplogForInsert, ts: Timestamp) {
+	return hasTs(log) ? log : { ...log, ts }
+}
+export function withAg(log: ApplogForInsertOptionalAgent, ag: AgentHash) {
+	return hasAg(log) ? log : { ...log, ag }
+}
+export function withPvFrom(log: PartialBy<ApplogNoCid, 'pv'>, thread: Thread /*OnlyCurrent*/ | null) {
+	DEBUG(`[withPvFrom] ENTER - en=${log.en}, at=${log.at}, hasPv=${log.pv !== undefined}`)
+	if (log.pv !== undefined) {
+		DEBUG(`[withPvFrom] EXIT early - pv already set`)
+		return log as ApplogNoCid // TODO: ? devMode WARN if it's different for catching bugs)
+	}
+	if (!thread) {
+		if (!hasPv(log)) throw ERROR(`[withPvFrom] no thread and no pv:`, log)
+		DEBUG(`[withPvFrom] EXIT - no thread, returning log with existing pv`)
+		return log // satisfies Pick<Applog, 'pv'>
+	} else {
+		const { en, at } = log
+		DEBUG(`[withPvFrom] About to call thread.findLast for en=${en}, at=${at}, thread.size=${thread.size}`)
+		const prevLog = thread.findLast(l => l.en == en && l.at == at) // HACK to not do lastWriteWins calc
+		DEBUG(`[withPvFrom] findLast completed, found=${!!prevLog}`)
+		// const prevLogs = rollingFilter(thread, { en, at }) // ? use some non-reactive filter here?
+		// if (prevLogs.size > 1) throw ERROR(`[withPvFrom] unexpected previous count:`, prevLogs.size, { log, prevLogs, thread }) // `thread` arg must be only current
+		// let prevLog = prevLogs.isEmpty ? null : prevLogs.applogs[0]
+		// const isMatchingPv = prevLog?.cid === log.pv
+		DEBUG(`[withPvFrom] About to check equality`)
+		if (objEqualByKeys(['en', 'at', 'vl', 'ts', 'ag'], log, prevLog)) {
+			throw ERROR(`[withPvFrom] Same as previous:`, { log, pv: prevLog, thread }) // bug catcher
+		}
+		// if (log.pv && !isMatchingPv) { // ineffective bc. shortcut in the beginning of this func
+		// 	WARN(`[withPvFrom] different than pre-set pv:`, { queriedPv: prevLog, logPv: log.pv })
+		// }
+		const prevLogCid = (log.pv !== undefined ? log.pv : prevLog?.cid) ?? null
+		DEBUG(`[withPvFrom] EXIT - prevLogCid=${prevLogCid}`)
+		return { ...log, pv: prevLogCid }
+	}
+}
+export function joinThreads(threads: ReadonlyArray<Thread>) {
+	const fullJoin = () => {
+		if (threads.length < 2) DEBUG(`joinThreads with count=${threads.length}`) // ? EmptyThread
+		return sortApplogsByTs(
+			removeDuplicateAppLogs(threads.flatMap(s => {
+				const logs = s.applogs
+				if (!logs) {
+					ERROR(`falsy applogs of thread`, s)
+					throw new Error(`falsy applogs of thread`)
+				}
+				return logs
+			}), 'cleanup'),
+		)
+	}
+	let initialMergeResult = fullJoin()
+	const eventMapper: ApplogEventMapper = function(event, sourceThread) {
+		if (isInitEvent(event)) {
+			return { init: fullJoin() }
+		} else {
+			// if (event.removed) WARN(`JoinThreads with parents removing stuff - NOT IMPLEMENTED CORRECTLY`, { event, joined: this, sourceThread }) // TODO: joinTHreads & removed?
+			return {
+				// TODO: test this stuff
+				added: event.added.filter(addedLog => !this.hasApplog(addedLog, true)),
+				removed: event.removed?.filter(removedLog => {
+					const otherParentHasLog = !this.parents.some(parent => {
+						if (parent === sourceThread) return false
+						return parent.hasApplog(removedLog, true)
+					})
+					return !otherParentHasLog
+				}),
+			}
+		}
+	}
+	return new MappedThread(
+		`join(~ ${threads.map(s => s.name).join(', ')})`,
+		threads,
+		['?'], // HACK this basically says "we're not sure what filters are applied"
+		initialMergeResult,
+		eventMapper,
+	)
+}