@wowok/agent-mcp 3.4.3 → 3.4.4

package/dist/data/projection/types.d.ts

@@ -1,169 +0,0 @@
-import type { WowTypedObjectKind } from "@wowok/wowok";
-export type ObjectVersionState = "active" | "deleted" | "wrapped";
-export interface ObjectVersionFact {
-    chainId: string;
-    objectId: string;
-    objectVersion: bigint;
-    moveType: string;
-    ownerKind: string;
-    ownerAddress?: string;
-    payloadUri: string;
-    payloadHash: string;
-    payloadFormat: string;
-    payloadJson?: Record<string, unknown> | null;
-    checkpoint: bigint;
-    txDigest: string;
-    previousVersion?: bigint;
-    state: ObjectVersionState;
-    observedAt: Date;
-}
-export type ApplyProjectionStatus = "applied" | "duplicate" | "stale" | "quarantined" | "conflict";
-export interface ApplyProjectionResult {
-    status: ApplyProjectionStatus;
-    currentVersion?: string;
-    reasonCode?: string;
-}
-export interface CurrentObject {
-    objectId: string;
-    objectVersion: string;
-    kindHint: number;
-    verifiedKind: WowTypedObjectKind;
-    shardCount: number;
-    shardIndex: number;
-    moveType: string;
-    checkpoint: string;
-    state: ObjectVersionState;
-    payloadHash: string;
-    payloadUri: string;
-    payloadFormat: string;
-    payloadJson: Record<string, unknown> | null;
-    ownerKind: string;
-    ownerAddress?: string;
-    updatedAt: string;
-}
-export interface ProjectionCoverage {
-    mode: "known_objects";
-    complete: false;
-    truncated: boolean;
-    total_enumerated: number;
-    chain_id: string;
-    reconciled_through: string | null;
-    degraded_reasons: string[];
-}
-export interface CurrentObjectPage {
-    objects: CurrentObject[];
-    next_cursor: string | null;
-    coverage: ProjectionCoverage;
-}
-export interface ProjectionWatermark {
-    verified_kind: WowTypedObjectKind;
-    max_checkpoint: string | null;
-    active_objects: number;
-}
-export interface QuarantineEntry {
-    object_id: string | null;
-    object_version: string;
-    reason_code: string;
-    first_seen: string | null;
-    current_version: string | null;
-    verified_kind: WowTypedObjectKind | null;
-    blocking: boolean;
-}
-export interface GraphEdgeView {
-    src: string;
-    srcKind: string;
-    edge: string;
-    dst: string;
-    dstKind: string;
-    objectVersion: string;
-    dstProjected: boolean;
-}
-export interface AggregateOptions {
-    chainId: string;
-    group: string;
-    groupId?: string;
-    metric: string;
-    excludeClaimed: boolean;
-    limit: number;
-}
-export interface AggregateRow {
-    group_id: string;
-    count: number;
-    metric_sum: string;
-    max_checkpoint: string;
-}
-export interface AggregateAnswer {
-    rows: AggregateRow[];
-    totals: {
-        count: number;
-        metric_sum: string;
-    };
-    truncated: boolean;
-}
-export interface ObjectFacetRow {
-    objectId: string;
-    verifiedKind: string;
-    objectVersion: string;
-    facetVersion: string;
-    industry: string | null;
-    industryConfidence: number;
-    location: string | null;
-    priceMin: string | null;
-    priceMax: string | null;
-    capabilities: string[];
-    published: boolean;
-    paused: boolean;
-    nameTokens: string[];
-    textTokens: string[];
-    keywords: string[];
-    checkpoint: string;
-}
-export interface ProjectionStatus {
-    chain_id: string;
-    raw_versions: number;
-    current_objects: number;
-    active_objects: number;
-    quarantined_versions: number;
-    max_checkpoint: string | null;
-    observed_at: string | null;
-    coverage: ProjectionCoverage;
-    reconciliations: ReconciliationGeneration[];
-}
-export interface ReconciliationGeneration {
-    kind: string;
-    generation: number;
-    reconciled_through: string;
-    verdict: string;
-    completed_at: string;
-    missing_count: number;
-    extra_count: number;
-    version_drift_count: number;
-}
-export interface RecordReconciliationOptions {
-    chainId: string;
-    kind: string;
-    runId: string;
-    liveSetCheckpoint: string;
-    missing: string[];
-    extra: string[];
-    versionDrift: string[];
-    preDiff: {
-        missing: number;
-        extra: number;
-        versionDrift: number;
-    };
-    repairs: {
-        missing: number;
-        drift: number;
-        tombstoned: number;
-    };
-    liveCount: number;
-    projectionActive: number;
-    error?: string;
-}
-export interface RecordReconciliationResult {
-    runId: string;
-    verdict: "pass" | "fail";
-    generation: number | null;
-    reconciledThrough: string | null;
-}

package/dist/data/sync/cdc.d.ts

@@ -1,33 +0,0 @@
-import { WowClient, WowGraphQLClient, type ENTRYPOINT } from "@wowok/wowok";
-import { GraphQLSnapshotSource } from "./graphql-source.js";
-import type { CdcChangeBatch, CdcHead, CdcRoundResult, CdcSource, RunCdcOptions } from "./types.js";
-export type { CdcChangeBatch, CdcHead, CdcSource, RunCdcOptions } from "./types.js";
-export declare class GraphQLCdcSource implements CdcSource {
-    private readonly graphql;
-    private readonly snapshot;
-    private readonly rpc;
-    private readonly expectedChainId;
-    constructor(graphql: WowGraphQLClient, snapshot: GraphQLSnapshotSource, rpc: WowClient, expectedChainId: string);
-    static forNetwork(network: ENTRYPOINT, expectedChainId: string): GraphQLCdcSource;
-    head(): Promise<CdcHead>;
-    readChanges(after: string, before: string, kind: string): Promise<CdcChangeBatch>;
-}
-export interface CdcProjection {
-    apply(input: unknown): Promise<{
-        status: string;
-    }>;
-    markTombstoneIfKind(chainId: string, objectId: string, kind: string): Promise<boolean>;
-}
-export interface CdcCursorStore {
-    cdcCheckpoint(chainId: string, kind: string): Promise<string | null>;
-    setCdcCheckpoint(chainId: string, kind: string, checkpoint: string): Promise<void>;
-    withCdcLock<T>(chainId: string, kind: string, work: () => Promise<T>): Promise<T>;
-}
-export declare class CdcSynchronizer {
-    private readonly projection;
-    private readonly source;
-    private readonly cursors;
-    constructor(projection: CdcProjection, source: CdcSource, cursors: CdcCursorStore);
-    run(options: RunCdcOptions): Promise<CdcRoundResult>;
-    private poll;
-}

package/dist/data/sync/cdc.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/data/sync/cdc.spec.js

@@ -1 +0,0 @@
-import{toBase58}from'@wowok/wowok';import{DataType,newDb}from'pg-mem';import{afterEach,beforeEach,describe,expect,it,vi}from'vitest';import{PostgresProjectionStore}from'../projection/store.js';import{CdcSynchronizer}from'./cdc.js';import{PostgresSyncStore}from'./store.js';const digest=toBase58(new Uint8Array(0x20)['fill'](0x7));function objectId(a){return'0x14'+a['toString'](0x10)['padStart'](0x2,'0')['repeat'](0x1f);}function fact(a,b={}){return{'chain_id':'chain_a','object_id':objectId(a),'object_version':'1','move_type':'0x2::service::Service<0x2::wow::WOW>','owner_kind':'Shared','payload_uri':'test://raw/service-'+a,'payload_hash':'0x'+'41'['repeat'](0x20),'payload_format':'json+bcs-v1','checkpoint':'100','tx_digest':digest,'state':'active','observed_at':'2026-10-24T00:00:00.000Z',...b};}class FakeCdcSource{['headCheckpoint'];['batches'];['chainId'];['calls']=[];constructor(a,b,c='chain_a'){this['headCheckpoint']=a,this['batches']=b,this['chainId']=c;}async['head'](){return{'chainId':this['chainId'],'checkpoint':this['headCheckpoint']};}async['readChanges'](a,b){this['calls']['push']({'after':a,'before':b});const c=this['batches']['get'](a+':'+b);if(!c)return{'facts':[],'deletedIds':[],'observedThrough':a,'pages':0x0};return c;}}function options(a,b={}){return{'expectedChainId':a['chainId'],'kind':'Service',...b};}describe('CdcSynchronizer',()=>{let a,b,c;beforeEach(async()=>{const e=newDb();e['public']['registerFunction']({'name':'pg_advisory_xact_lock','args':[DataType['integer'],DataType['integer']],'returns':DataType['integer'],'implementation':()=>0x0});const {Pool:f}=e['adapters']['createPg']();c=new f(),a=new PostgresProjectionStore(c,0x10),b=new PostgresSyncStore(c),await a['migrate'](),await b['migrate']();}),afterEach(async()=>{await a?.['close'](),await b?.['close'](),vi['restoreAllMocks']();});function d(e,f){return new FakeCdcSource(e,f??new Map());}it('anchors\x20at\x20head\x20on\x20the\x20first\x20run\x20without\x20applying\x20anything',async()=>{const e=d('120'),f=await new CdcSynchronizer(a,e,b)['run'](options(e));expect(f)['toMatchObject']({'anchored':!![],'from':null,'to':'120','applied':0x0}),expect(await b['cdcCheckpoint']('chain_a','Service'))['toBe']('120'),expect(await a['status']('chain_a'))['toMatchObject']({'active_objects':0x0});}),it('re-anchors\x20a\x20stranded\x20cursor\x20instead\x20of\x20grinding\x20empty\x20intervals',async()=>{await b['setCdcCheckpoint']('chain_a','Service','100');const e=d('2000'),f=await new CdcSynchronizer(a,e,b)['run'](options(e,{'stalledLag':0x1f4}));expect(f)['toMatchObject']({'anchored':![],'reanchored_from':'100','from':'100','to':'2000','applied':0x0}),expect(e['calls'])['toEqual']([]),expect(await b['cdcCheckpoint']('chain_a','Service'))['toBe']('2000');}),it('grinds\x20a\x20lagged\x20cursor\x20when\x20the\x20stall\x20threshold\x20is\x20disabled',async()=>{await b['setCdcCheckpoint']('chain_a','Service','100');const e=d('2000'),f=await new CdcSynchronizer(a,e,b)['run'](options(e,{'stalledLag':0x0,'maxSpan':0x32}));expect(f)['toMatchObject']({'reanchored_from':null,'to':'100'}),expect(e['calls'])['toEqual']([{'after':'100','before':'151'}]);}),it('applies\x20facts\x20in\x20the\x20interval\x20and\x20advances\x20to\x20observedThrough',async()=>{await b['setCdcCheckpoint']('chain_a','Service','100');const e=d('150',new Map([['100:151',{'facts':[fact(0x1),fact(0x2,{'object_version':'2','checkpoint':'140'})],'deletedIds':[],'observedThrough':'140','pages':0x2}]])),f=await new CdcSynchronizer(a,e,b)['run'](options(e));expect(f)['toMatchObject']({'anchored':![],'from':'100','to':'140','head':'150','applied':0x2,'pages':0x2}),expect(e['calls'])['toEqual']([{'after':'100','before':'151'}]),expect(await b['cdcCheckpoint']('chain_a','Service'))['toBe']('140'),expect(await a['status']('chain_a'))['toMatchObject']({'active_objects':0x2});}),it('clamps\x20the\x20interval\x20to\x20maxSpan\x20and\x20requests\x20the\x20half-open\x20bound',async()=>{await b['setCdcCheckpoint']('chain_a','Service','100');const e=d('1000');await new CdcSynchronizer(a,e,b)['run'](options(e,{'maxSpan':0x32})),expect(e['calls'])['toEqual']([{'after':'100','before':'151'}]),expect(await b['cdcCheckpoint']('chain_a','Service'))['toBe']('100');}),it('is\x20a\x20no-op\x20when\x20head\x20has\x20not\x20advanced',async()=>{await b['setCdcCheckpoint']('chain_a','Service','150');const e=d('150'),f=await new CdcSynchronizer(a,e,b)['run'](options(e));expect(f)['toMatchObject']({'from':'150','to':'150','applied':0x0}),expect(e['calls'])['toEqual']([]);}),it('replays\x20idempotently\x20after\x20a\x20crash\x20between\x20apply\x20and\x20cursor\x20advance',async()=>{await b['setCdcCheckpoint']('chain_a','Service','100');const e=new Map([['100:102',{'facts':[fact(0x1)],'deletedIds':[],'observedThrough':'101','pages':0x1}]]),f=new FakeCdcSource('101',e),g=new CdcSynchronizer(a,f,b),h=await g['run'](options(f));expect(h['applied'])['toBe'](0x1),await c['query']('UPDATE\x20cdc_cursor\x20SET\x20checkpoint=100\x20WHERE\x20chain_id=$1\x20AND\x20kind=$2',['chain_a','Service']);const i=await g['run'](options(f));expect(i)['toMatchObject']({'applied':0x0,'duplicate':0x1,'to':'101'}),expect(await a['status']('chain_a'))['toMatchObject']({'active_objects':0x1,'raw_versions':0x1});}),it('tombstones\x20kind-matched\x20deletions\x20only',async()=>{await a['apply'](fact(0x1));const e='0x12'+'02'['repeat'](0x1f);await a['apply'](fact(0x2,{'object_id':e,'move_type':'0x2::arb::Arb','payload_uri':'test://raw/arb-2'})),await b['setCdcCheckpoint']('chain_a','Service','100');const f=d('120',new Map([['100:121',{'facts':[],'deletedIds':[objectId(0x1),e,objectId(0x3)],'observedThrough':'120','pages':0x1}]])),g=await new CdcSynchronizer(a,f,b)['run'](options(f));expect(g['tombstoned'])['toBe'](0x1);const h=await a['listCurrent']({'chainId':'chain_a','kind':'Service'});expect(h['objects'])['toHaveLength'](0x0);const i=await a['listCurrent']({'chainId':'chain_a','kind':'Arb'});expect(i['objects'])['toHaveLength'](0x1);}),it('keeps\x20the\x20cursor\x20forward-only\x20when\x20the\x20source\x20reports\x20stale\x20intervals',async()=>{await b['setCdcCheckpoint']('chain_a','Service','150');const e=d('120'),f=await new CdcSynchronizer(a,e,b)['run'](options(e));expect(f)['toMatchObject']({'from':'150','to':'150','head':'120'}),expect(await b['cdcCheckpoint']('chain_a','Service'))['toBe']('150');}),it('does\x20not\x20advance\x20past\x20what\x20the\x20source\x20returned',async()=>{await b['setCdcCheckpoint']('chain_a','Service','100');const e=d('150',new Map([['100:151',{'facts':[],'deletedIds':[],'observedThrough':'130','pages':0x1}]])),f=await new CdcSynchronizer(a,e,b)['run'](options(e));expect(f['to'])['toBe']('130'),expect(await b['cdcCheckpoint']('chain_a','Service'))['toBe']('130');});});

package/dist/data/sync/graphql-source.d.ts

@@ -1,16 +0,0 @@
-import { ENTRYPOINT, WowClient, WowGraphQLClient } from "@wowok/wowok";
-import type { SnapshotObservation, SnapshotPage, SnapshotPageRequest, SnapshotSource } from "./types.js";
-export declare function canonicalChainIdentifier(value: string): string;
-export declare function factFromRpc(network: ENTRYPOINT, chainId: string, checkpoint: string, rpc: Record<string, any>, observedAt: string): Record<string, unknown> | null;
-export declare class GraphQLSnapshotSource implements SnapshotSource {
-    private readonly graphql;
-    private readonly rpc;
-    private readonly network;
-    private readonly expectedChainId;
-    constructor(graphql: WowGraphQLClient, rpc: WowClient, network: ENTRYPOINT, expectedChainId: string);
-    static forNetwork(network: ENTRYPOINT, expectedChainId: string): GraphQLSnapshotSource;
-    observe(): Promise<SnapshotObservation>;
-    readPage(request: SnapshotPageRequest): Promise<SnapshotPage>;
-    private fetchRpcShapes;
-    hydrateFacts(objectIds: string[], chainId: string, checkpoint: string, signal?: AbortSignal): Promise<Record<string, unknown>[]>;
-}

package/dist/data/sync/index.d.ts

@@ -1,5 +0,0 @@
-export { canonicalChainIdentifier, GraphQLSnapshotSource } from "./graphql-source.js";
-export { SYNC_SCHEMA_SQL } from "./schema.js";
-export { PostgresSyncStore } from "./store.js";
-export { SnapshotSynchronizer } from "./synchronizer.js";
-export type { CompleteSyncRunOptions, ReconciliationResult, RunSnapshotSyncOptions, SaveSyncPageOptions, SnapshotObservation, SnapshotPage, SnapshotPageRequest, SnapshotScope, SnapshotSource, SnapshotSyncResult, StartSyncRunOptions, SyncRun, } from "./types.js";

package/dist/data/sync/reconciler.d.ts

@@ -1,14 +0,0 @@
-import type { ApplyProjectionResult, RecordReconciliationOptions, RecordReconciliationResult } from "../projection/types.js";
-import type { LiveSetReconciliationResult, RunLiveSetReconciliationOptions, SnapshotSource } from "./types.js";
-export interface ReconciliationProjection {
-    liveSetVersions(chainId: string, kind: string): Promise<Map<string, string>>;
-    apply(input: unknown): Promise<ApplyProjectionResult>;
-    markTombstone(chainId: string, objectId: string): Promise<boolean>;
-    recordReconciliation(options: RecordReconciliationOptions): Promise<RecordReconciliationResult>;
-}
-export declare class LiveSetReconciler {
-    private readonly projection;
-    private readonly source;
-    constructor(projection: ReconciliationProjection, source: SnapshotSource);
-    run(options: RunLiveSetReconciliationOptions): Promise<LiveSetReconciliationResult>;
-}

package/dist/data/sync/reconciler.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/data/sync/reconciler.spec.js

@@ -1 +0,0 @@
-import{toBase58}from'@wowok/wowok';import{DataType,newDb}from'pg-mem';import{afterEach,beforeEach,describe,expect,it,vi}from'vitest';import{PostgresProjectionStore}from'../projection/store.js';import{LiveSetReconciler}from'./reconciler.js';const digest=toBase58(new Uint8Array(0x20)['fill'](0x7));function objectId(a){return'0x14'+a['toString'](0x10)['padStart'](0x2,'0')['repeat'](0x1f);}function fact(a,b={}){return{'chain_id':'chain_a','object_id':objectId(a),'object_version':'1','move_type':'0x2::service::Service<0x2::wow::WOW>','owner_kind':'Shared','payload_uri':'test://raw/service-'+a,'payload_hash':'0x'+'41'['repeat'](0x20),'payload_format':'json+bcs-v1','checkpoint':'100','tx_digest':digest,'state':'active','observed_at':'2026-10-24T00:00:00.000Z',...b};}function page(a,b,c='100'){return{'chainId':'chain_a','checkpoint':c,'facts':a,'nextCursor':b,'hasNextPage':b!==null};}class FakeSource{['pages'];['chainId'];['checkpoint'];['cursors']=[];constructor(a,b='chain_a',c='100'){this['pages']=a,this['chainId']=b,this['checkpoint']=c;}async['observe'](){return{'chainId':this['chainId'],'checkpoint':this['checkpoint']};}async['readPage'](a){this['cursors']['push'](a['cursor']);const b=a['cursor']===null?0x0:this['pages']['findIndex'](c=>c['nextCursor']===a['cursor'])+0x1;if(b<0x0||b>=this['pages']['length'])throw new Error('Invalid\x20test\x20cursor');return this['pages'][b];}}function options(a){return{'expectedChainId':a['chainId'],'type':'0x2::service','kind':'Service','limit':0x32};}describe('LiveSetReconciler',()=>{let a,b;beforeEach(async()=>{const c=newDb();c['public']['registerFunction']({'name':'pg_advisory_xact_lock','args':[DataType['integer'],DataType['integer']],'returns':DataType['integer'],'implementation':()=>0x0});const {Pool:d}=c['adapters']['createPg']();b=new d(),a=new PostgresProjectionStore(b,0x10),await a['migrate']();}),afterEach(async()=>{await a?.['close'](),vi['restoreAllMocks']();}),it('passes\x20and\x20publishes\x20generation\x201\x20on\x20an\x20empty\x20live\x20set',async()=>{const c=new FakeSource([page([],null)]),d=await new LiveSetReconciler(a,c)['run'](options(c));expect(d)['toMatchObject']({'verdict':'pass','generation':0x1,'reconciled_through':'100','pre_diff':{'missing':0x0,'extra':0x0,'version_drift':0x0},'repairs':{'missing':0x0,'drift':0x0,'tombstoned':0x0}});const e=await a['status']('chain_a');expect(e['coverage'])['toMatchObject']({'reconciled_through':'100','degraded_reasons':[]}),expect(e['reconciliations'])['toHaveLength'](0x1),expect(e['reconciliations'][0x0])['toMatchObject']({'kind':'Service','generation':0x1,'verdict':'pass'});}),it('repairs\x20a\x20missing\x20object\x20and\x20drops\x20RECONCILIATION_REQUIRED\x20from\x20coverage',async()=>{const c=new FakeSource([page([fact(0x1)],null)]),d=await new LiveSetReconciler(a,c)['run'](options(c));expect(d)['toMatchObject']({'verdict':'pass','generation':0x1,'pre_diff':{'missing':0x1,'extra':0x0,'version_drift':0x0},'repairs':{'missing':0x1,'drift':0x0,'tombstoned':0x0},'residual':{'missing':[],'extra':[],'version_drift':[]}});const e=await a['status']('chain_a');expect(e)['toMatchObject']({'active_objects':0x1}),expect(e['coverage']['degraded_reasons'])['toEqual']([]);const f=await a['listCurrent']({'chainId':'chain_a','kind':'Service'});expect(f['coverage']['reconciled_through'])['toBe']('100'),expect(f['objects'])['toHaveLength'](0x1);}),it('tombstones\x20an\x20extra\x20object\x20without\x20deleting\x20the\x20row',async()=>{await a['apply'](fact(0x2));const c=new FakeSource([page([],null)]),d=await new LiveSetReconciler(a,c)['run'](options(c));expect(d)['toMatchObject']({'verdict':'pass','pre_diff':{'missing':0x0,'extra':0x1,'version_drift':0x0},'repairs':{'missing':0x0,'drift':0x0,'tombstoned':0x1},'residual':{'missing':[],'extra':[],'version_drift':[]}});const e=await b['query']('SELECT\x20state\x20FROM\x20object_current\x20WHERE\x20chain_id=\x27chain_a\x27\x20AND\x20object_id=$1',[Buffer['from']('14'+'02'['repeat'](0x1f),'hex')]);expect(e['rows'])['toEqual']([{'state':'deleted'}]);}),it('repairs\x20version\x20drift\x20by\x20re-applying\x20the\x20chain\x20fact',async()=>{await a['apply'](fact(0x1));const c=new FakeSource([page([fact(0x1,{'object_version':'2','previous_version':'1','checkpoint':'101','payload_uri':'test://raw/service-1-v2'})],null,'101')]),d=await new LiveSetReconciler(a,c)['run'](options(c));expect(d)['toMatchObject']({'verdict':'pass','reconciled_through':'101','pre_diff':{'missing':0x0,'extra':0x0,'version_drift':0x1},'repairs':{'missing':0x0,'drift':0x1,'tombstoned':0x0},'residual':{'missing':[],'extra':[],'version_drift':[]}});const e=await a['listCurrent']({'chainId':'chain_a','kind':'Service'});expect(e['objects'][0x0])['toMatchObject']({'objectVersion':'2','checkpoint':'101'});}),it('fails\x20closed\x20without\x20bumping\x20generation\x20when\x20a\x20repair\x20is\x20rejected',async()=>{const c=fact(0x1,{'payload_hash':'0xzz-not-hex'}),d=new FakeSource([page([c],null)]),e=await new LiveSetReconciler(a,d)['run'](options(d));expect(e['verdict'])['toBe']('fail'),expect(e['generation'])['toBeNull'](),expect(e['reconciled_through'])['toBeNull'](),expect(e['repairs']['missing'])['toBe'](0x0),expect(e['residual']['missing'])['toEqual']([objectId(0x1)]),expect(e['error'])['toContain']('REPAIR_FAILED');const f=await a['status']('chain_a');expect(f['coverage']['degraded_reasons'])['toContain']('RECONCILIATION_REQUIRED'),expect(f['reconciliations'][0x0])['toMatchObject']({'verdict':'fail','generation':0x0});}),it('bumps\x20the\x20generation\x20on\x20each\x20subsequent\x20passing\x20run',async()=>{const c=new FakeSource([page([fact(0x1)],null)]),d=new LiveSetReconciler(a,c),e=await d['run'](options(c)),f=await d['run'](options(c));expect(e['generation'])['toBe'](0x1),expect(f)['toMatchObject']({'verdict':'pass','generation':0x2,'repairs':{'missing':0x0,'drift':0x0,'tombstoned':0x0},'pre_diff':{'missing':0x0,'extra':0x0,'version_drift':0x0}}),expect((await a['status']('chain_a'))['reconciliations'][0x0]['generation'])['toBe'](0x2);}),it('rejects\x20a\x20source\x20reporting\x20a\x20different\x20chain\x20identity',async()=>{const c=new FakeSource([page([],null)],'chain_b');await expect(new LiveSetReconciler(a,c)['run'](options(c)))['rejects']['toThrow']('CHAIN_IDENTITY_MISMATCH'),expect(await a['status']('chain_a')['then'](d=>d['reconciliations']))['toEqual']([]);});});

package/dist/data/sync/schema.d.ts

@@ -1 +0,0 @@
-export declare const SYNC_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS sync_run (\n    chain_id TEXT NOT NULL,\n    stream TEXT NOT NULL,\n    run_id TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('running', 'complete', 'failed')),\n    scope_kind TEXT,\n    shard_count INTEGER,\n    shard_index INTEGER,\n    cursor TEXT,\n    checkpoint BIGINT,\n    pages INTEGER NOT NULL DEFAULT 0,\n    objects BIGINT NOT NULL DEFAULT 0,\n    started_at TIMESTAMPTZ NOT NULL,\n    updated_at TIMESTAMPTZ NOT NULL,\n    completed_at TIMESTAMPTZ,\n    error TEXT,\n    PRIMARY KEY (chain_id, stream)\n);\n\nCREATE TABLE IF NOT EXISTS sync_seen (\n    chain_id TEXT NOT NULL,\n    stream TEXT NOT NULL,\n    run_id TEXT NOT NULL,\n    object_id BYTEA NOT NULL,\n    object_version BIGINT NOT NULL,\n    PRIMARY KEY (chain_id, stream, object_id)\n);\n\nCREATE INDEX IF NOT EXISTS sync_seen_run\n    ON sync_seen (chain_id, stream, run_id, object_id);\n\nCREATE TABLE IF NOT EXISTS sync_page (\n    chain_id TEXT NOT NULL,\n    stream TEXT NOT NULL,\n    run_id TEXT NOT NULL,\n    page_seq INTEGER NOT NULL,\n    checkpoint BIGINT NOT NULL,\n    objects INTEGER NOT NULL DEFAULT 0,\n    cursor TEXT,\n    created_at TIMESTAMPTZ NOT NULL,\n    PRIMARY KEY (chain_id, stream, run_id, page_seq)\n);\n\n-- W3 CDC cursor. Semantics: every checkpoint up to and including the stored\n-- value has been fully applied for (chain_id, kind). Advances only to the\n-- highest checkpoint actually observed in returned transaction nodes \u2014 never\n-- to the requested interval end \u2014 so indexer lag can never skip transactions.\nCREATE TABLE IF NOT EXISTS cdc_cursor (\n    chain_id TEXT NOT NULL,\n    kind TEXT NOT NULL,\n    checkpoint BIGINT NOT NULL,\n    updated_at TIMESTAMPTZ NOT NULL,\n    PRIMARY KEY (chain_id, kind)\n);\n";

package/dist/data/sync/store.d.ts

@@ -1,24 +0,0 @@
-import { Pool } from "pg";
-import type { CompleteSyncRunOptions, ReconciliationResult, SaveSyncPageOptions, StartSyncRunOptions, SyncRun } from "./types.js";
-export declare class PostgresSyncStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    static fromDatabaseUrl(databaseUrl: string): PostgresSyncStore;
-    migrate(): Promise<void>;
-    close(): Promise<void>;
-    private locked;
-    start(options: StartSyncRunOptions): Promise<SyncRun>;
-    savePage(options: SaveSyncPageOptions): Promise<SyncRun>;
-    complete(options: CompleteSyncRunOptions): Promise<ReconciliationResult>;
-    private verifyPageLedger;
-    fail(chainId: string, stream: string, runId: string, error: unknown): Promise<void>;
-    status(chainId: string): Promise<SyncRun[]>;
-    cdcCursors(chainId: string): Promise<Array<{
-        kind: string;
-        checkpoint: string;
-        updated_at: string;
-    }>>;
-    cdcCheckpoint(chainId: string, kind: string): Promise<string | null>;
-    setCdcCheckpoint(chainId: string, kind: string, checkpoint: string): Promise<void>;
-    withCdcLock<T>(chainId: string, kind: string, work: () => Promise<T>): Promise<T>;
-}

package/dist/data/sync/sync.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/data/sync/sync.spec.js

@@ -1 +0,0 @@
-import{ENTRYPOINT,toBase58}from'@wowok/wowok';import{DataType,newDb}from'pg-mem';import{afterEach,beforeEach,describe,expect,it,vi}from'vitest';import{PostgresProjectionStore}from'../projection/store.js';import{GraphQLSnapshotSource}from'./graphql-source.js';import{PostgresSyncStore}from'./store.js';import{SnapshotSynchronizer}from'./synchronizer.js';const digest=toBase58(new Uint8Array(0x20)['fill'](0x7)),chainDigest=toBase58(new Uint8Array([0xa9,0x15,0x5c,0xf,...new Uint8Array(0x1c)['fill'](0x7)]));function objectId(a){return'0x14'+a['toString'](0x10)['padStart'](0x2,'0')['repeat'](0x1f);}function fact(a,b={}){return{'chain_id':'chain_a','object_id':objectId(a),'object_version':'1','move_type':'0x2::service::Service<0x2::wow::WOW>','owner_kind':'Shared','payload_uri':'test://raw/service-'+a,'payload_hash':'0x'+'41'['repeat'](0x20),'payload_format':'json+bcs-v1','checkpoint':'100','tx_digest':digest,'state':'active','observed_at':'2026-10-24T00:00:00.000Z',...b};}function page(a,b,c='100'){return{'chainId':'chain_a','checkpoint':c,'facts':a,'nextCursor':b,'hasNextPage':b!==null};}class FakeSource{['pages'];['chainId'];['checkpoint'];['cursors']=[];['failAtCursor'];['failed']=![];constructor(a,b='chain_a',c='100'){this['pages']=a,this['chainId']=b,this['checkpoint']=c;}async['observe'](){return{'chainId':this['chainId'],'checkpoint':this['checkpoint']};}async['readPage'](a){this['cursors']['push'](a['cursor']);if(!this['failed']&&this['failAtCursor']!==undefined&&a['cursor']===this['failAtCursor']){this['failed']=!![];throw new Error('injected\x20page\x20failure');}const b=a['cursor']===null?0x0:this['pages']['findIndex'](c=>c['nextCursor']===a['cursor'])+0x1;if(b<0x0||b>=this['pages']['length'])throw new Error('Invalid\x20test\x20cursor');return this['pages'][b];}}function options(a){return{'expectedChainId':a['chainId'],'stream':'graphql-shared:Service','type':'0x2::service','scope':{'kind':'Service'},'limit':0x32};}describe('SnapshotSynchronizer',()=>{let a,b,c;beforeEach(async()=>{const f=newDb();f['public']['registerFunction']({'name':'pg_advisory_xact_lock','args':[DataType['integer'],DataType['integer']],'returns':DataType['integer'],'implementation':()=>0x0});const {Pool:g}=f['adapters']['createPg']();a=new PostgresProjectionStore(new g(),0x10),c=new g(),b=new PostgresSyncStore(c),await a['migrate'](),await b['migrate']();}),afterEach(async()=>{await a?.['close'](),await b?.['close'](),vi['restoreAllMocks']();}),it('persists\x20a\x20complete\x20paginated\x20run\x20without\x20claiming\x20CDC\x20completeness',async()=>{const f=new FakeSource([page([fact(0x1)],'cursor-1'),page([fact(0x2)],null,'101')]),g=await new SnapshotSynchronizer(a,b,f)['run'](options(f));expect(g)['toMatchObject']({'applied':0x2,'duplicate':0x0,'enumeration_complete':!![],'missing_objects':0x0,'current_active':0x2}),expect(g['run'])['toMatchObject']({'state':'complete','pages':0x2,'objects':0x2,'checkpoint':'101'}),expect(g['coverage'])['toMatchObject']({'complete':![],'degraded_reasons':['SNAPSHOT_NOT_CHECKPOINT_PINNED','INCREMENTAL_CDC_REQUIRED']}),expect(f['cursors'])['toEqual']([null,'cursor-1']);}),it('reconciles\x20a\x20later\x20snapshot\x20without\x20conflicting\x20on\x20observation\x20checkpoints',async()=>{const f=new FakeSource([page([fact(0x1)],null)]),g=new SnapshotSynchronizer(a,b,f);await g['run'](options(f));const h=new FakeSource([page([fact(0x1,{'checkpoint':'101'})],null,'101')],'chain_a','101'),i=new SnapshotSynchronizer(a,b,h)['run'](options(h));await expect(i)['resolves']['toMatchObject']({'applied':0x0,'duplicate':0x1,'conflict':0x0,'missing_objects':0x0}),expect(await a['status']('chain_a'))['toMatchObject']({'raw_versions':0x1,'quarantined_versions':0x0});}),it('resumes\x20from\x20the\x20last\x20committed\x20page\x20after\x20a\x20source\x20failure',async()=>{const f=new FakeSource([page([fact(0x1)],'cursor-1'),page([fact(0x2)],null,'101')]);f['failAtCursor']='cursor-1';const g=new SnapshotSynchronizer(a,b,f);await expect(g['run'](options(f)))['rejects']['toThrow']('injected\x20page\x20failure'),expect((await b['status']('chain_a'))[0x0])['toMatchObject']({'state':'failed','cursor':'cursor-1','pages':0x1});const h=await g['run'](options(f));expect(h['run'])['toMatchObject']({'state':'complete','resumed':!![],'pages':0x2,'objects':0x2}),expect(h['applied'])['toBe'](0x1),expect(f['cursors'])['toEqual']([null,'cursor-1','cursor-1']);}),it('replays\x20facts\x20idempotently\x20when\x20a\x20crash\x20precedes\x20cursor\x20persistence',async()=>{const f=new FakeSource([page([fact(0x1)],null)]);vi['spyOn'](b,'savePage')['mockRejectedValueOnce'](new Error('injected\x20cursor\x20failure'));const g=new SnapshotSynchronizer(a,b,f);await expect(g['run'](options(f)))['rejects']['toThrow']('injected\x20cursor\x20failure');const h=await g['run'](options(f));expect(h)['toMatchObject']({'applied':0x0,'duplicate':0x1,'missing_objects':0x0}),expect(await a['status']('chain_a'))['toMatchObject']({'raw_versions':0x1,'active_objects':0x1}),expect(f['cursors'])['toEqual']([null,null]);}),it('reports\x20current\x20objects\x20missing\x20from\x20the\x20enumerated\x20live\x20set',async()=>{await a['apply'](fact(0x2));const f=new FakeSource([page([fact(0x1)],null)]),g=await new SnapshotSynchronizer(a,b,f)['run'](options(f));expect(g['missing_objects'])['toBe'](0x1),expect(g['missing_object_ids'])['toEqual']([objectId(0x2)]),expect(g['coverage']['degraded_reasons'])['toContain']('LIVE_SET_MISSING'),expect(g['coverage']['complete'])['toBe'](![]);}),it('rejects\x20an\x20object\x20changing\x20versions\x20between\x20snapshot\x20pages',async()=>{const f=new FakeSource([page([fact(0x1)],'cursor-1'),page([fact(0x1,{'object_version':'2','checkpoint':'101'})],null,'101')]),g=new SnapshotSynchronizer(a,b,f);await expect(g['run'](options(f)))['rejects']['toThrow']('NON_STABLE_SNAPSHOT'),expect((await b['status']('chain_a'))[0x0])['toMatchObject']({'state':'failed','pages':0x1});}),it('starts\x20a\x20fresh\x20enumeration\x20after\x20a\x20non-stable\x20snapshot',async()=>{const f=new FakeSource([page([fact(0x1)],'cursor-1'),page([fact(0x1,{'object_version':'2','checkpoint':'101'})],null,'101')]);await expect(new SnapshotSynchronizer(a,b,f)['run'](options(f)))['rejects']['toThrow']('NON_STABLE_SNAPSHOT');const g=(await b['status']('chain_a'))[0x0],h=new FakeSource([page([fact(0x1,{'object_version':'2','checkpoint':'101'})],null,'101')],'chain_a','101'),i=await new SnapshotSynchronizer(a,b,h)['run'](options(h));expect(i['run']['runId'])['not']['toBe'](g['runId']),expect(i)['toMatchObject']({'duplicate':0x1,'missing_objects':0x0});}),it('rejects\x20checkpoint\x20regression\x20and\x20chain\x20identity\x20mismatch',async()=>{const f=new FakeSource([page([fact(0x1)],null,'99')]);await expect(new SnapshotSynchronizer(a,b,f)['run'](options(f)))['rejects']['toThrow']('CHAIN_CHECKPOINT_REGRESSION');const g=new FakeSource([],'chain_b');await expect(new SnapshotSynchronizer(a,b,g)['run']({...options(g),'expectedChainId':'chain_a'}))['rejects']['toThrow']('CHAIN_IDENTITY_MISMATCH'),expect(await b['status']('chain_b'))['toEqual']([]);});function d(f){const g=b['savePage']['bind'](b);let h=![];vi['spyOn'](b,'savePage')['mockImplementation'](async i=>{const j=await g(i);return!h&&j['cursor']===null&&(h=!![],await f(j['runId'])),j;});}function e(){return new FakeSource([page([fact(0x1)],'cursor-1'),page([fact(0x2)],null,'101')]);}it('records\x20a\x20contiguous\x20page\x20ledger\x20and\x20completes\x20without\x20false\x20positives',async()=>{const f=e(),g=await new SnapshotSynchronizer(a,b,f)['run'](options(f));expect(g['run'])['toMatchObject']({'state':'complete','pages':0x2});const h=await c['query']('SELECT\x20page_seq,\x20checkpoint,\x20objects\x20FROM\x20sync_page\x20ORDER\x20BY\x20page_seq');expect(h['rows']['map'](i=>[Number(i['page_seq']),String(i['checkpoint']),Number(i['objects'])]))['toEqual']([[0x1,'100',0x1],[0x2,'101',0x1]]);}),it('refuses\x20to\x20complete\x20when\x20a\x20ledger\x20row\x20disappears',async()=>{const f=e();d(async h=>{await c['query']('DELETE\x20FROM\x20sync_page\x20WHERE\x20run_id=$1\x20AND\x20page_seq=1',[h]);});const g=new SnapshotSynchronizer(a,b,f);await expect(g['run'](options(f)))['rejects']['toThrow']('CHECKPOINT_GAP_DETECTED'),expect((await b['status']('chain_a'))[0x0])['toMatchObject']({'state':'failed'});}),it('refuses\x20to\x20complete\x20when\x20ledger\x20page\x20numbering\x20breaks',async()=>{const f=e();d(async h=>{await c['query']('UPDATE\x20sync_page\x20SET\x20page_seq=5\x20WHERE\x20run_id=$1\x20AND\x20page_seq=2',[h]);});const g=new SnapshotSynchronizer(a,b,f);await expect(g['run'](options(f)))['rejects']['toThrow'](/CHECKPOINT_GAP_DETECTED.*sequence break/),expect((await b['status']('chain_a'))[0x0])['toMatchObject']({'state':'failed'});}),it('refuses\x20to\x20complete\x20when\x20a\x20ledger\x20checkpoint\x20regresses',async()=>{const f=e();d(async h=>{await c['query']('UPDATE\x20sync_page\x20SET\x20checkpoint=99\x20WHERE\x20run_id=$1\x20AND\x20page_seq=2',[h]);});const g=new SnapshotSynchronizer(a,b,f);await expect(g['run'](options(f)))['rejects']['toThrow'](/CHECKPOINT_GAP_DETECTED.*regressed/),expect((await b['status']('chain_a'))[0x0])['toMatchObject']({'state':'failed'});});}),describe('GraphQLSnapshotSource',()=>{const a='0x0000000000000000000000000000000000000000000000000000000000000002',b={'struct':{'type':'0x1::string::String','fields':[{'name':'bytes','layout':{'vector':'u8'}}]}},c={'struct':{'type':a+'::service::Service<'+a+'::wow::WOW>','fields':[{'name':'name','layout':b}]}};function d(e='a9155c0f'){const f={'core':{'getChainIdentifier':vi['fn'](async()=>({'chainIdentifier':chainDigest}))},'listSharedObjects':vi['fn'](async()=>({'objects':[{'objectId':objectId(0x1),'version':'3','digest':digest,'type':a+'::service::Service<'+a+'::wow::WOW>','owner':{'$kind':'Shared','Shared':{'initialSharedVersion':'1'}},'previousTransaction':digest}],'cursor':null,'hasNextPage':![]})),'getObjects':vi['fn'](async()=>({'objects':[{'objectId':objectId(0x1),'version':'3','digest':digest,'type':a+'::service::Service<'+a+'::wow::WOW>','owner':{'$kind':'Shared','Shared':{'initialSharedVersion':'1'}},'previousTransaction':digest,'json':{'name':'one'},'layout':c}]}))},g={'getChainIdentifier':vi['fn'](async()=>e),'getLatestCheckpointSequenceNumber':vi['fn'](async()=>'100'),'multiGetObjects':vi['fn'](async()=>[])};return{'graphql':f,'rpc':g};}it('maps\x20read-only\x20chain\x20objects\x20into\x20validated\x20projection\x20inputs',async()=>{const {graphql:e,rpc:f}=d(),g=new GraphQLSnapshotSource(e,f,ENTRYPOINT['Testnet'],'a9155c0f'),h=await g['readPage']({'type':'0x2::service','cursor':null,'limit':0x32});expect(h['facts'][0x0])['toMatchObject']({'chain_id':'a9155c0f','object_id':objectId(0x1),'object_version':'3','move_type':'0x2::service::Service<0x2::wow::WOW>','checkpoint':'100','tx_digest':digest,'payload_format':'rpc-content-v1','payload_json':{'name':'one'},'state':'active'});}),it('fails\x20closed\x20when\x20the\x20fetched\x20version\x20drifts\x20from\x20the\x20enumeration',async()=>{const {graphql:e,rpc:f}=d();e['getObjects']['mockResolvedValueOnce']({'objects':[{'objectId':objectId(0x1),'version':'4','digest':digest,'type':a+'::service::Service<'+a+'::wow::WOW>','owner':{'$kind':'Shared','Shared':{'initialSharedVersion':'1'}},'previousTransaction':digest,'json':{'name':'one'},'layout':c}]});const g=new GraphQLSnapshotSource(e,f,ENTRYPOINT['Testnet'],'a9155c0f');await expect(g['readPage']({'type':'0x2::service','cursor':null,'limit':0x32}))['rejects']['toThrow']('NON_STABLE_SNAPSHOT');}),it('fails\x20closed\x20when\x20GraphQL\x20and\x20JSON-RPC\x20identities\x20differ',async()=>{const {graphql:e,rpc:f}=d();f['getChainIdentifier']['mockResolvedValue']('deadbeef');const g=new GraphQLSnapshotSource(e,f,ENTRYPOINT['Testnet'],'a9155c0f');await expect(g['observe']())['rejects']['toThrow']('CHAIN_IDENTITY_MISMATCH');});});

package/dist/data/sync/synchronizer.d.ts

@@ -1,10 +0,0 @@
-import type { PostgresProjectionStore } from "../projection/store.js";
-import type { PostgresSyncStore } from "./store.js";
-import type { RunSnapshotSyncOptions, SnapshotSource, SnapshotSyncResult } from "./types.js";
-export declare class SnapshotSynchronizer {
-    private readonly projection;
-    private readonly sync;
-    private readonly source;
-    constructor(projection: PostgresProjectionStore, sync: PostgresSyncStore, source: SnapshotSource);
-    run(options: RunSnapshotSyncOptions): Promise<SnapshotSyncResult>;
-}

package/dist/data/sync/types.d.ts

@@ -1,164 +0,0 @@
-import type { WowTypedObjectKind } from "@wowok/wowok";
-import type { ProjectionCoverage } from "../projection/types.js";
-export interface SnapshotScope {
-    kind?: WowTypedObjectKind;
-    shard?: {
-        count: number;
-        index: number;
-    };
-}
-export interface SnapshotPageRequest {
-    type: string;
-    cursor: string | null;
-    limit: number;
-    signal?: AbortSignal;
-}
-export interface SnapshotPage {
-    chainId: string;
-    checkpoint: string;
-    facts: unknown[];
-    nextCursor: string | null;
-    hasNextPage: boolean;
-}
-export interface SnapshotObservation {
-    chainId: string;
-    checkpoint: string;
-}
-export interface SnapshotSource {
-    observe(): Promise<SnapshotObservation>;
-    readPage(request: SnapshotPageRequest): Promise<SnapshotPage>;
-}
-export interface SyncRun {
-    chainId: string;
-    stream: string;
-    runId: string;
-    state: "running" | "complete" | "failed";
-    scope: SnapshotScope;
-    cursor: string | null;
-    checkpoint: string | null;
-    pages: number;
-    objects: number;
-    startedAt: string;
-    updatedAt: string;
-    completedAt: string | null;
-    error: string | null;
-    resumed: boolean;
-}
-export interface StartSyncRunOptions {
-    chainId: string;
-    stream: string;
-    scope: SnapshotScope;
-    checkpoint: string;
-}
-export interface SaveSyncPageOptions {
-    chainId: string;
-    stream: string;
-    runId: string;
-    cursor: string | null;
-    checkpoint: string;
-    objects: Array<{
-        objectId: string;
-        objectVersion: bigint;
-    }>;
-}
-export interface CompleteSyncRunOptions {
-    chainId: string;
-    stream: string;
-    runId: string;
-    degradedReasons?: string[];
-}
-export interface ReconciliationResult {
-    run: SyncRun;
-    enumeration_complete: true;
-    current_active: number;
-    missing_objects: number;
-    missing_object_ids: string[];
-    missing_truncated: boolean;
-    coverage: ProjectionCoverage;
-}
-export interface RunSnapshotSyncOptions {
-    expectedChainId: string;
-    stream: string;
-    type: string;
-    scope: SnapshotScope;
-    limit?: number;
-    signal?: AbortSignal;
-}
-export interface SnapshotSyncResult extends ReconciliationResult {
-    applied: number;
-    duplicate: number;
-    stale: number;
-    quarantined: number;
-    conflict: number;
-}
-export interface RunLiveSetReconciliationOptions {
-    expectedChainId: string;
-    type: string;
-    kind: string;
-    limit?: number;
-    signal?: AbortSignal;
-}
-export interface LiveSetReconciliationResult {
-    runId: string;
-    chainId: string;
-    checkpoint: string;
-    kind: string;
-    verdict: "pass" | "fail";
-    generation: number | null;
-    reconciled_through: string | null;
-    live_count: number;
-    projection_active: number;
-    pre_diff: {
-        missing: number;
-        extra: number;
-        version_drift: number;
-    };
-    repairs: {
-        missing: number;
-        drift: number;
-        tombstoned: number;
-    };
-    residual: {
-        missing: string[];
-        extra: string[];
-        version_drift: string[];
-    };
-    error: string | null;
-}
-export interface CdcHead {
-    chainId: string;
-    checkpoint: string;
-}
-export interface CdcChangeBatch {
-    facts: unknown[];
-    deletedIds: string[];
-    observedThrough: string;
-    pages: number;
-}
-export interface CdcSource {
-    head(): Promise<CdcHead>;
-    readChanges(after: string, before: string, kind: string): Promise<CdcChangeBatch>;
-}
-export interface RunCdcOptions {
-    expectedChainId: string;
-    kind: string;
-    maxSpan?: number;
-    stalledLag?: number;
-}
-export interface CdcRoundResult {
-    chainId: string;
-    kind: string;
-    anchored: boolean;
-    reanchored_from: string | null;
-    from: string | null;
-    to: string | null;
-    head: string;
-    pages: number;
-    applied: number;
-    duplicate: number;
-    stale: number;
-    quarantined: number;
-    conflict: number;
-    tombstoned: number;
-    skipped_facts: number;
-}

package/dist/evaluation/acceptance.d.ts

@@ -1,33 +0,0 @@
-import type { EvaluationRule } from "./types.js";
-export declare const PRESENTER_HISTORY_KEY = "presenter_history";
-export interface PresenterAcceptanceRecord {
-    demand_id?: string;
-    presenter?: string;
-    presenter_service?: string;
-    acceptance_score: number | null;
-    feedback_time?: number;
-}
-export declare const COUNTERPARTY_LIKE_THRESHOLD = 60;
-export interface AcceptanceSummary {
-    score: number | null;
-    rated: number;
-    total: number;
-    average: number | null;
-    clamped: number;
-}
-export declare function summarizeAcceptance(records: PresenterAcceptanceRecord[]): AcceptanceSummary;
-export declare function presenterHistoryFromEntities(entities: Record<string, unknown>): PresenterAcceptanceRecord[];
-export declare function applyCounterpartyFeedback<T extends {
-    object: string;
-}>(services: T[], records: PresenterAcceptanceRecord[]): T[];
-export declare function recordsForService(records: PresenterAcceptanceRecord[], serviceObject: string | undefined | null): PresenterAcceptanceRecord[];
-export interface AcceptanceRuleOptions {
-    weight: number;
-    weightOf?: () => number;
-    dimension?: string;
-    redFlag?: {
-        below: number;
-        minRated: number;
-    };
-}
-export declare function createAcceptanceRule(evaluationId: string, opts: AcceptanceRuleOptions): EvaluationRule;

package/dist/evaluation/architecture.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/evaluation/architecture.spec.js

@@ -1 +0,0 @@
-import{describe,expect,it}from'vitest';import{dirname,join}from'node:path';import{fileURLToPath}from'node:url';import{ENTRYPOINT}from'@wowok/wowok';import{FakeDataPlane}from'../graph/onchain/dataplane.js';import{expandTopology}from'../graph/onchain/expand.js';import{FULL,fullServiceState}from'../graph/onchain/fixtures.js';import{buildViewport}from'../graph/onchain/viewport.js';import{runAnalyzers}from'../graph/onchain/analyze.js';import{RETENTION_RANK}from'../graph/onchain/analyze.js';import{EVALUATION_SERVICE_INTENTS,resolveExpansionStrategy,withEvaluationBundle}from'../graph/onchain/strategy.js';import{projectEvaluationFacts}from'../graph/onchain/facts.js';import{registerGraphServiceEvaluations}from'./builtins/graph-service.js';import{importSourcesOf,listRuntimeSources,namedSdkImportsOf,onchainIoCalls,SDK_CONSTANT_ALLOWLIST}from'./guard-scan.js';const EVAL_DIR=dirname(fileURLToPath(import.meta.url)),GRAPH_ONCHAIN_DIR=join(EVAL_DIR,'..','graph','onchain'),DATA_PLANE_IMPLS=new Set(['sdk-dataplane.ts','sdk-batch.ts']),CONFIDENCES=new Set(['exact','bounded','windowed','derived']);describe('Task\x2017\x20engine\x20purity\x20architecture\x20guard\x20(TR-17.1)',()=>{it('(a)\x20evaluation/\x20runtime\x20files:\x20relative\x20imports\x20only,\x20no\x20chain-IO\x20entry',async()=>{const a=await import('../playbooks/service-build/topology-query.js');expect(typeof a['evaluateServiceFromGraph'])['toBe']('function');const b=listRuntimeSources(EVAL_DIR);expect(b['length'])['toBeGreaterThan'](0x0);for(const {file:c,text:d}of b){for(const e of importSourcesOf(d)){if(e['startsWith']('.'))continue;if(e['startsWith']('node:'))continue;if(e==='@wowok/wowok'){const f=namedSdkImportsOf(d)['filter'](g=>!SDK_CONSTANT_ALLOWLIST['has'](g));expect(f,c+'\x20imports\x20non-constant\x20SDK\x20symbols:\x20'+f['join'](',\x20'))['toEqual']([]);continue;}throw new Error(c+'\x20imports\x20non-relative\x20module\x20\x22'+e+'\x22\x20—\x20evaluation\x20must\x20stay\x20pure');}expect(onchainIoCalls(d),c+'\x20performs\x20chain\x20IO')['toEqual']([]);}}),it('(b)\x20every\x20projected\x20Fact\x20carries\x20provenance\x20(path/retention/confidence)',async()=>{registerGraphServiceEvaluations();const a=withEvaluationBundle(resolveExpansionStrategy({'intents':[...EVALUATION_SERVICE_INTENTS]})),b=await expandTopology(new FakeDataPlane(fullServiceState()),{'network':ENTRYPOINT['Mainnet'],'seed':FULL['svc'],'budget':a['budget'],'edges':a['edges']}),c=buildViewport(b,FULL['svc'],'neutral'),d=projectEvaluationFacts(c,FULL['svc'],runAnalyzers(c));expect(d['facts']['length'])['toBeGreaterThan'](0x0);for(const e of d['facts']){const f=e['provenance'];expect(f,e['dimension']+'/'+e['key']+'\x20has\x20no\x20provenance')['toBeDefined'](),expect(Array['isArray'](f['path'])&&f['path']['length']>0x0,e['dimension']+'/'+e['key']+'\x20provenance.path\x20empty')['toBe'](!![]),expect(f['path']['every'](g=>typeof g==='string'&&g!==''),e['dimension']+'/'+e['key']+'\x20provenance.path\x20has\x20non-string\x20segments')['toBe'](!![]),expect(RETENTION_RANK[f['retention']],e['dimension']+'/'+e['key']+'\x20unknown\x20retention\x20'+f['retention'])['toBeDefined'](),expect(CONFIDENCES['has'](f['confidence']),e['dimension']+'/'+e['key']+'\x20unknown\x20confidence\x20'+f['confidence'])['toBe'](!![]);}for(const g of d['slots']){expect(typeof g['slot'])['toBe']('string'),expect(['present','empty','gap'])['toContain'](g['state']);}}),it('(c)\x20graph/onchain\x20chain\x20IO\x20lives\x20only\x20in\x20the\x20DataPlane\x20implementations',()=>{const a=listRuntimeSources(GRAPH_ONCHAIN_DIR);expect(a['length'])['toBeGreaterThan'](0x0);const b=a['filter'](({file:c,text:d})=>!DATA_PLANE_IMPLS['has'](c)&&onchainIoCalls(d)['length']>0x0)['map'](({file:c})=>c);expect(b,'evaluation\x20fetch\x20path\x20leaked\x20outside\x20the\x20DataPlane\x20implementations:\x20'+b['join'](',\x20'))['toEqual']([]);}),it('red-light:\x20the\x20scanners\x20flag\x20violation\x20samples',()=>{expect(onchainIoCalls('const\x20p\x20=\x20new\x20SdkDataPlane(net);\x20await\x20query_table({...});'))['toEqual'](expect['arrayContaining'](['SdkDataPlane\x20construction','SDK\x20query\x20call'])),expect(onchainIoCalls('const\x20names\x20=\x20await\x20LocalMark.Instance().get_many_address(x);'))['toEqual'](expect['arrayContaining'](['LocalMark\x20store\x20access'])),expect(namedSdkImportsOf('import\x20{\x20LocalMark\x20}\x20from\x20\x22@wowok/wowok\x22;'))['toEqual'](['LocalMark']),expect(onchainIoCalls('//\x20pulled\x20by\x20the\x20handler\x20via\x20query_arbs\x0aexport\x20const\x20K\x20=\x201;'))['toEqual']([]);});});

package/dist/evaluation/builtins/arbitration-score.d.ts

@@ -1,42 +0,0 @@
-import type { EvaluationResult, UserInjection } from "../types.js";
-export declare const ARBITRATION_TRUST_EVALUATION = "arbitration_trust";
-export declare const ARBITRATION_FAIRNESS_EVALUATION = "arbitration_fairness";
-export interface ArbitrationConfigInput {
-    object?: string;
-    fee?: number | bigint | string;
-    balance?: number | bigint | string;
-    voting_guard_count?: number;
-    bPaused?: boolean;
-    location?: string;
-    has_verified_identity?: boolean;
-    usage_guard?: string | null;
-}
-export interface ArbCaseInput {
-    status?: number | string;
-    time?: number;
-    resolved_time?: number;
-    indemnity_amount?: number | bigint | string;
-    feedback_positive?: boolean;
-    objected?: boolean;
-    customer?: string;
-    merchant?: string;
-}
-export interface EntityReputationInput {
-    like_ratio?: number;
-    favor?: boolean;
-}
-export interface ArbitrationScoreInput {
-    arbitration: ArbitrationConfigInput;
-    history?: ArbCaseInput[];
-    entity_votes?: EntityReputationInput;
-    fee_median?: number | bigint | string;
-}
-export interface ArbitrationScoreResult {
-    trust: EvaluationResult;
-    fairness: EvaluationResult;
-    combined: number;
-    summary: string;
-    cold_start?: boolean;
-}
-export declare function registerArbitrationScoreEvaluation(engine?: import("../engine.js").EvaluationEngine): void;
-export declare function assessArbitration(input: ArbitrationScoreInput, injection?: UserInjection): Promise<ArbitrationScoreResult>;

package/dist/evaluation/builtins/demand-match.d.ts

@@ -1,16 +0,0 @@
-import { type PresenterAcceptanceRecord } from "../acceptance.js";
-import { type CapabilityVector } from "../capability.js";
-import { type DemandExtractInput, type ServiceExtractInput } from "../extract.js";
-import type { EvaluationResult, UserInjection } from "../types.js";
-export declare const DEMAND_MATCH_EVALUATION = "demand_match";
-export declare function registerDemandMatchEvaluation(engine?: import("../engine.js").EvaluationEngine): void;
-export interface DemandMatch {
-    service: ServiceExtractInput;
-    result: EvaluationResult;
-}
-export declare function matchDemandToServices(demandCap: CapabilityVector, services: ServiceExtractInput[], injection?: UserInjection, limit?: number, presenterHistory?: PresenterAcceptanceRecord[]): Promise<DemandMatch[]>;
-export interface ServiceMatch {
-    demand: DemandExtractInput;
-    result: EvaluationResult;
-}
-export declare function matchServiceToDemands(serviceCap: CapabilityVector, demands: DemandExtractInput[], injection?: UserInjection, limit?: number, presenterHistory?: PresenterAcceptanceRecord[]): Promise<ServiceMatch[]>;