@tangleai/outcomes 0.24.1

package/src/adapters/direction-delta.d.ts

@@ -0,0 +1,2 @@
+import type { OutcomeAdapter } from '../adapters.ts';
+export declare function createDirectionDeltaAdapter(): Promise<OutcomeAdapter>;

package/src/adapters/direction-delta.gen.d.ts

@@ -0,0 +1,13 @@
+export interface Input {
+    base: number;
+}
+export interface Output {
+    predicted: number;
+}
+export interface Resolution {
+    actual: number;
+}
+export interface Artifact {
+    offset: number;
+}
+export type DirectionDelta = Artifact;

package/src/adapters/direction-delta.gen.js

@@ -0,0 +1,3 @@
+// Generated by @jarenjs/emit from packages/outcomes/schemas/direction-delta.schema.json.
+// Do not edit: regenerate instead.
+export {};

package/src/adapters/direction-delta.js

@@ -0,0 +1,29 @@
+/** A finite scalar correction policy with a strict, unrounded tolerance. */
+import schema from '../../schemas/direction-delta.schema.json' with { type: 'json' };
+import { adapterIdentity, domainValidator } from "../domain.js";
+import { reject } from "../errors.js";
+export async function createDirectionDeltaAdapter() {
+    const schemas = schema.$defs;
+    const input = domainValidator(schemas.input), output = domainValidator(schemas.output);
+    const resolution = domainValidator(schemas.resolution), artifact = domainValidator(schemas.artifact);
+    return Object.freeze({
+        identity: await adapterIdentity('direction-delta/v1', schemas, { tolerance: 0.05, comparison: 'strict', zero: 'nonnegative', interpreter: 'base+offset' }),
+        schemas, staticPayload: { offset: 0 }, validatePayload: () => [],
+        interpret(raw, payload) {
+            const { base } = input(raw), { offset } = artifact(payload);
+            const predicted = base + offset;
+            if (!Number.isFinite(predicted))
+                reject('OUTC1010', 'Scalar addition is not finite.');
+            return { predicted };
+        },
+        score(raw, evidence) {
+            const { predicted } = output(raw), { actual } = resolution(evidence);
+            const sameDirection = (predicted >= 0 && actual >= 0) || (predicted < 0 && actual < 0);
+            const difference = Math.abs(predicted - actual);
+            return {
+                outcome: sameDirection ? difference < 0.05 ? 'success' : 'partial' : 'failure',
+                diagnostics: { sameDirection, difference: Number.isFinite(difference) ? difference : null, differenceOverflow: !Number.isFinite(difference) },
+            };
+        },
+    });
+}

package/src/adapters/exact-match.d.ts

@@ -0,0 +1,2 @@
+import type { OutcomeAdapter } from '../adapters.ts';
+export declare function createExactMatchAdapter(): Promise<OutcomeAdapter>;

package/src/adapters/exact-match.gen.d.ts

@@ -0,0 +1,39 @@
+export interface Input {
+    /**
+     * Schema constraints this type cannot express: minLength=1, pattern="\\S"
+     */
+    token: string;
+}
+export interface Output {
+    /**
+     * Schema constraints this type cannot express: minLength=1, pattern="\\S"
+     */
+    label: string;
+}
+export interface Resolution {
+    /**
+     * Schema constraints this type cannot express: minLength=1, pattern="\\S"
+     */
+    label: string;
+}
+export interface ArtifactRulesItem {
+    /**
+     * Schema constraints this type cannot express: minLength=1, pattern="\\S"
+     */
+    prefix: string;
+    /**
+     * Schema constraints this type cannot express: minLength=1, pattern="\\S"
+     */
+    label: string;
+}
+export interface Artifact {
+    /**
+     * Schema constraints this type cannot express: minLength=1, pattern="\\S"
+     */
+    fallbackLabel: string;
+    /**
+     * Schema constraints this type cannot express: maxItems=16
+     */
+    rules: Array<ArtifactRulesItem>;
+}
+export type ExactMatch = Artifact;

package/src/adapters/exact-match.gen.js

@@ -0,0 +1,3 @@
+// Generated by @jarenjs/emit from packages/outcomes/schemas/exact-match.schema.json.
+// Do not edit: regenerate instead.
+export {};

package/src/adapters/exact-match.js

@@ -0,0 +1,40 @@
+/** Exact labels and a bounded, deterministic prefix interpreter. */
+import schema from '../../schemas/exact-match.schema.json' with { type: 'json' };
+import { adapterIdentity, domainValidator } from "../domain.js";
+import { issue, reject } from "../errors.js";
+function codePointOrder(a, b) {
+    const x = Array.from(a, c => c.codePointAt(0)), y = Array.from(b, c => c.codePointAt(0));
+    for (let i = 0; i < Math.min(x.length, y.length); i++)
+        if (x[i] !== y[i])
+            return x[i] - y[i];
+    return x.length - y.length;
+}
+export async function createExactMatchAdapter() {
+    const schemas = schema.$defs;
+    const input = domainValidator(schemas.input), output = domainValidator(schemas.output);
+    const resolution = domainValidator(schemas.resolution), artifact = domainValidator(schemas.artifact);
+    const normalize = (raw) => {
+        const payload = artifact(raw);
+        return { ...payload, rules: [...payload.rules].sort((a, b) => Array.from(b.prefix).length - Array.from(a.prefix).length || codePointOrder(a.prefix, b.prefix)) };
+    };
+    return Object.freeze({
+        identity: await adapterIdentity('exact-match/v1', schemas, { scorer: 'case-sensitive equality', interpreter: 'longest Unicode code-point prefix; code-point tie order', normalization: 'none' }),
+        schemas, staticPayload: { fallbackLabel: 'unknown', rules: [] },
+        normalizePayload: raw => artifact(normalize(raw)),
+        validatePayload(raw) {
+            const payload = artifact(raw);
+            return new Set(payload.rules.map(r => r.prefix)).size === payload.rules.length ? [] : [issue('OUTC1010', 'Prefixes must be unique.')];
+        },
+        interpret(raw, payload) {
+            const { token } = input(raw), p = normalize(payload);
+            if (new Set(p.rules.map(r => r.prefix)).size !== p.rules.length)
+                reject('OUTC1010', 'Prefixes must be unique.');
+            return { label: p.rules.find(r => token.startsWith(r.prefix))?.label ?? p.fallbackLabel };
+        },
+        score(raw, evidence) {
+            const a = output(raw), b = resolution(evidence);
+            const equal = a.label === b.label;
+            return { outcome: equal ? 'success' : 'failure', diagnostics: { equal } };
+        },
+    });
+}

package/src/adapters.d.ts

@@ -0,0 +1,50 @@
+/** Host-owned domain schemas and pure evaluators; no provider or domain registry globals. */
+import type { Json, AdapterIdentity, Scope, Source, SourceRef, Issue, EvaluationSlot, ProposalReply } from './outcomes.contracts.gen.ts';
+import type { RunIdentity } from '@tangleai/config';
+export type { EvaluationSlot } from './outcomes.contracts.gen.ts';
+export interface OutcomeAdapter {
+    readonly identity: AdapterIdentity;
+    readonly schemas: {
+        input: object;
+        output: object;
+        resolution: object;
+        artifact: object;
+    };
+    readonly staticPayload: Json;
+    score(output: Json, resolution: Json): {
+        outcome: 'success' | 'partial' | 'failure';
+        diagnostics: Json;
+    };
+    interpret(input: Json, payload: Json): Json;
+    validatePayload(payload: Json): Issue[];
+    normalizePayload?(payload: Json): Json;
+}
+export interface EvidenceResolver {
+    readonly revision: string;
+    resolve(reference: SourceRef, scope: Scope): Promise<Source | undefined>;
+}
+export interface OutcomePrincipal {
+    id: string;
+    authorityId: string;
+    approve: boolean;
+    reconcile: boolean;
+}
+export interface OutcomeProposer {
+    readonly identity: RunIdentity;
+    propose(input: Json, hooks: {
+        onDispatch(requestDigest: string): Promise<void>;
+    }): Promise<ProposalReply>;
+}
+export interface OutcomeHost {
+    principal?: OutcomePrincipal;
+    scope: Scope;
+    adapters: readonly OutcomeAdapter[];
+    resolver: EvidenceResolver;
+    authorizeMemoryIds(ids: readonly string[], scope: Scope): Promise<{
+        allowed: boolean;
+        authorizationId: string;
+    }>;
+    evaluationSlot?(slotId: string, versionId: string, scope: Scope): Promise<EvaluationSlot | undefined>;
+    proposer?: OutcomeProposer;
+    resolveConfiguration?(identityId: string): Promise<RunIdentity | undefined>;
+}

package/src/adapters.js

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