@hashgraphonline/standards-sdk 0.1.184 → 0.1.186

package/dist/browser/hcs-25/signals/operational.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operational.d.ts","sourceRoot":"","sources":["../../../../src/hcs-25/signals/operational.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAgB1B,CAAC;AAKjB;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA8BnB,CAAC;AAmBjB;;;;GAIG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAoBjC,CAAC"}

package/dist/browser/hcs-25/signals/simple-evals.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import { Hcs25SignalStatus } from '../types';
+/**
+ * Status tokens emitted by simple eval runners, per the HCS-25 simple-evals
+ * methodology.
+ */
+export type Hcs25SimpleEvalStatus = 'correct' | 'wrong' | 'unparseable' | 'timeout' | 'missing' | 'empty' | 'skipped' | 'upstream-error' | 'error';
+/**
+ * A graded simple-eval outcome. Scores are binary per the methodology.
+ */
+export interface Hcs25SimpleEvalGrade {
+    status: Hcs25SimpleEvalStatus;
+    score: number;
+}
+/**
+ * Maps a simple-eval status token onto an HCS-25 signal status code.
+ * Substantive outcomes stay `ok` because the stored score carries the value;
+ * skipped runs are treated as missing.
+ */
+export declare function mapSimpleEvalStatus(token: string | null): Hcs25SignalStatus;
+/**
+ * Grades a SimpleMath response by extracting the first numeric token and
+ * comparing it against the expected answer.
+ */
+export declare function gradeSimpleMathResponse(response: string, expected: number): Hcs25SimpleEvalGrade;
+declare const SCIENCE_CHOICE_LETTERS: readonly ["A", "B", "C", "D"];
+/**
+ * Grades a SimpleScience response by extracting a standalone `A|B|C|D`
+ * token, falling back to full option-text matching when options are
+ * provided.
+ */
+export declare function gradeSimpleScienceResponse(response: string, correctChoice: (typeof SCIENCE_CHOICE_LETTERS)[number], options?: readonly string[]): Hcs25SimpleEvalGrade;
+/**
+ * A generated SimpleMath question with its stable identifier and expected
+ * answer.
+ */
+export interface Hcs25SimpleMathQuestion {
+    questionId: string;
+    prompt: string;
+    expected: number;
+}
+/**
+ * Generates a random SimpleMath question. Operand ranges follow the
+ * methodology: addition uses two integers in 10–100, subtraction subtracts
+ * 1–50 from 10–100, and multiplication uses small integers in 2–12. Pass a
+ * seeded rng for deterministic generation.
+ */
+export declare function generateSimpleMathQuestion(rng?: () => number): Hcs25SimpleMathQuestion;
+/**
+ * A curated SimpleScience multiple-choice question with exactly four
+ * options and one unambiguous correct choice.
+ */
+export interface Hcs25SimpleScienceQuestion {
+    questionId: string;
+    prompt: string;
+    options: readonly [string, string, string, string];
+    correctChoice: (typeof SCIENCE_CHOICE_LETTERS)[number];
+}
+/**
+ * A small curated bank of basic science facts spanning chemistry, biology,
+ * physics, and earth science, per the methodology.
+ */
+export declare const SIMPLE_SCIENCE_QUESTION_BANK: readonly Hcs25SimpleScienceQuestion[];
+/**
+ * Samples a random science question from the curated bank. Pass a seeded rng
+ * for deterministic sampling.
+ */
+export declare function sampleSimpleScienceQuestion(rng?: () => number): Hcs25SimpleScienceQuestion;
+/**
+ * Stored-field schema for the shared A2A/NANDA simple-eval signal family.
+ * Field names follow the `a2aSimple*` / `nandaSimple*` conventions.
+ */
+export declare const hcs25SimpleEvalFieldsSchema: z.ZodObject<{
+    a2aSimpleMathScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    a2aSimpleMathStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    a2aSimpleScienceStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    nandaSimpleMathStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    nandaSimpleScienceStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    a2aSimpleMathScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    a2aSimpleMathStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    a2aSimpleScienceStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    nandaSimpleMathStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    nandaSimpleScienceStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    a2aSimpleMathScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    a2aSimpleMathStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleMathUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    a2aSimpleScienceStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    a2aSimpleScienceUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    nandaSimpleMathStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleMathUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceScore: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    nandaSimpleScienceStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceQuestionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceResponse: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nandaSimpleScienceUpdatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.ZodTypeAny, "passthrough">>;
+export {};
+//# sourceMappingURL=simple-evals.d.ts.map

package/dist/browser/hcs-25/signals/simple-evals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-evals.d.ts","sourceRoot":"","sources":["../../../../src/hcs-25/signals/simple-evals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAC7B,SAAS,GACT,OAAO,GACP,aAAa,GACb,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,gBAAgB,GAChB,OAAO,CAAC;AAEZ;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf;AAiBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,CAa3E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,oBAAoB,CAUtB;AAED,QAAA,MAAM,sBAAsB,+BAAgC,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,EACtD,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,oBAAoB,CAqBtB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAWD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,GAAE,MAAM,MAAoB,GAC9B,uBAAuB,CAkCzB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,aAAa,EAAE,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;CACxD;AAuBD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,0BAA0B,EAkD3E,CAAC;AAEJ;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,GAAE,MAAM,MAAoB,GAC9B,0BAA0B,CAK5B;AAED;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA6BxB,CAAC"}

package/dist/browser/hcs-25/types.d.ts

@@ -0,0 +1,363 @@
+import { z } from 'zod';
+/**
+ * JSON-compatible value carried by a trust signal.
+ */
+export type Hcs25JsonValue = string | number | boolean | null | Hcs25JsonValue[] | {
+    [key: string]: Hcs25JsonValue;
+};
+export declare const hcs25JsonValueSchema: z.ZodType<Hcs25JsonValue>;
+/**
+ * Signal status codes defined by HCS-25.
+ */
+export declare const hcs25SignalStatusSchema: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+export type Hcs25SignalStatus = z.infer<typeof hcs25SignalStatusSchema>;
+/**
+ * Optional provenance describing where a signal came from.
+ */
+export declare const hcs25SignalProvenanceSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+    subjectId: z.ZodOptional<z.ZodString>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodOptional<z.ZodString>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+    subjectId: z.ZodOptional<z.ZodString>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodOptional<z.ZodString>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+    subjectId: z.ZodOptional<z.ZodString>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type Hcs25SignalProvenance = z.infer<typeof hcs25SignalProvenanceSchema>;
+/**
+ * A single trust signal: a stable identifier-keyed measurement with a status
+ * and optional provenance.
+ */
+export declare const hcs25SignalSchema: z.ZodObject<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type Hcs25Signal = z.infer<typeof hcs25SignalSchema>;
+/**
+ * The set of trust signals currently known for a subject, keyed by namespaced
+ * signal identifier.
+ */
+export declare const hcs25SignalSnapshotSchema: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>>, Record<string, z.objectOutputType<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>, Record<string, z.objectInputType<{
+    status: z.ZodEnum<["ok", "missing", "timeout", "error", "stale"]>;
+    value: z.ZodOptional<z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodString>;
+        sourceUrl: z.ZodOptional<z.ZodString>;
+        subjectId: z.ZodOptional<z.ZodString>;
+        fetchedAt: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>>;
+export type Hcs25SignalSnapshot = Record<string, Hcs25Signal>;
+/**
+ * The AI system being scored.
+ */
+export declare const hcs25SubjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodString>;
+    class: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodString>;
+    class: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodString>;
+    class: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<Hcs25JsonValue, z.ZodTypeDef, Hcs25JsonValue>>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type Hcs25Subject = z.infer<typeof hcs25SubjectSchema>;
+/**
+ * Adapter participation policy in the composite denominator.
+ */
+export type Hcs25ContributionMode = 'universal' | 'scoped' | 'conditional';
+/**
+ * Output of an adapter component normalization function.
+ */
+export interface Hcs25NormalizedValue {
+    value: number;
+    status: Hcs25SignalStatus;
+}
+/**
+ * Inputs available to adapter normalization functions.
+ */
+export interface Hcs25NormalizationContext {
+    subject: Hcs25Subject;
+    snapshot: Hcs25SignalSnapshot;
+    config: Hcs25ScoringConfig;
+}
+/**
+ * Applicability constraints shared by adapters.
+ */
+export interface Hcs25ApplicabilityRule {
+    includeRegistries?: readonly string[];
+    excludeRegistries?: readonly string[];
+    appliesTo?: (subject: Hcs25Subject) => boolean;
+}
+/**
+ * A deterministic scoring function that maps one signal into one normalized
+ * component.
+ */
+export interface Hcs25ComponentDefinition {
+    name: string;
+    weight?: number;
+    nonScorableWhenUnavailable?: boolean;
+    normalize: (context: Hcs25NormalizationContext) => Hcs25NormalizedValue;
+}
+/**
+ * A trust score adapter: deterministic, CPU-bound, and explainable.
+ */
+export interface Hcs25AdapterDefinition extends Hcs25ApplicabilityRule {
+    id: string;
+    weight?: number;
+    contributionMode?: Hcs25ContributionMode;
+    defaultComponentKey?: string;
+    components: readonly Hcs25ComponentDefinition[];
+}
+/**
+ * Scoring configuration as provided by the caller; defaults are resolved by
+ * {@link compileScoringConfig}.
+ */
+export interface Hcs25ScoringConfigInput {
+    version: number;
+    adapters: readonly Hcs25AdapterDefinition[];
+    staleMultiplier?: number;
+    roundingDecimals?: number;
+    computeConfidence?: boolean;
+}
+/**
+ * Validated scoring configuration with defaults resolved.
+ */
+export interface Hcs25ScoringConfig {
+    version: number;
+    adapters: readonly Hcs25AdapterDefinition[];
+    staleMultiplier: number;
+    roundingDecimals: number;
+    computeConfidence: boolean;
+}
+export declare const HCS25_DEFAULT_WEIGHT = 1;
+export declare const HCS25_DEFAULT_CONTRIBUTION_MODE: Hcs25ContributionMode;
+export declare const HCS25_DEFAULT_STALE_MULTIPLIER = 1;
+export declare const HCS25_DEFAULT_ROUNDING_DECIMALS = 2;
+/**
+ * One normalized component emitted by an adapter.
+ */
+export interface Hcs25ComponentResult {
+    key: string;
+    value: number;
+    status: Hcs25SignalStatus;
+    weight: number;
+}
+/**
+ * Per-adapter scoring breakdown.
+ */
+export interface Hcs25AdapterScore {
+    adapterId: string;
+    contributionMode: Hcs25ContributionMode;
+    applicable: boolean;
+    inDenominator: boolean;
+    weight: number;
+    components: Hcs25ComponentResult[];
+    unavailable: string[];
+    total: number;
+}
+/**
+ * The HCS-25 score record emitted for a subject.
+ */
+export interface Hcs25TrustScoreRecord {
+    trustScore: number;
+    trustScores: Record<string, number>;
+    trustScoreConfigVersion: number;
+    trustScoreUpdatedAt: string;
+    trustConfidence?: number;
+    breakdown: {
+        adapters: Hcs25AdapterScore[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/browser/hcs-25/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/hcs-25/types.ts"],"names":[],"mappings":"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"}

package/dist/browser/index.d.ts

@@ -14,6 +14,7 @@ export * from './hcs-16';
 export * from './hcs-17';
 export * from './hcs-18';
 export * from './hcs-27';
+export * from './hcs-25';
 export * from './hcs-26';
 export * from './utils';
 export * from './inscribe';

package/dist/browser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC"}

package/dist/browser-root/hcs-25/adapters/acp.d.ts

@@ -0,0 +1,20 @@
+import { Hcs25AdapterDefinition } from '../types';
+/**
+ * Options for the ACP/Virtuals marketplace adapter.
+ */
+export interface Hcs25AcpAdapterOptions {
+    /** Volume cap used for log scaling delivery volume. Default 500. */
+    volumeCap?: number;
+    /** Revenue cap used for log scaling revenue. Default 10000. */
+    revenueCap?: number;
+    /** Registries where marketplace metrics apply. */
+    includeRegistries?: readonly string[];
+}
+/**
+ * Creates the `acp` adapter: normalizes marketplace-native execution
+ * performance (job success, delivery volume, revenue, ratings) for
+ * ACP/Virtuals-style agents. Delivery volume falls back to the successful
+ * job count when no provider-defined volume exists.
+ */
+export declare function createAcpAdapter(options?: Hcs25AcpAdapterOptions): Hcs25AdapterDefinition;
+//# sourceMappingURL=acp.d.ts.map

package/dist/browser-root/hcs-25/adapters/acp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp.d.ts","sourceRoot":"","sources":["../../../../src/hcs-25/adapters/acp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sBAAsB,EAGvB,MAAM,UAAU,CAAC;AAIlB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAeD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,sBAA2B,GACnC,sBAAsB,CAkDxB"}

package/dist/browser-root/hcs-25/adapters/agentverse.d.ts

@@ -0,0 +1,34 @@
+import { Hcs25AdapterDefinition } from '../types';
+/**
+ * Options for the AgentVerse insights adapter.
+ */
+export interface Hcs25AgentverseInsightsAdapterOptions {
+    /** Registries where AgentVerse insights apply. */
+    includeRegistries?: readonly string[];
+}
+/**
+ * Options for the AgentVerse verifier reliability adapter.
+ */
+export interface Hcs25AgentverseVerifierAdapterOptions {
+    /** Interaction count cap for the volume confidence factor. Default 1000. */
+    interactionCap?: number;
+    /** Average response time (seconds) that maps to a zero factor. Default 30. */
+    responseTimeCapSeconds?: number;
+    /** Registries where AgentVerse verifier counters apply. */
+    includeRegistries?: readonly string[];
+}
+/**
+ * Creates the `agentverse-insights` adapter: converts marketplace "insights"
+ * indicators into a single normalized component, preferring the explicit
+ * rating (scaled from five) and falling back to the mean of the available
+ * quality proxies.
+ */
+export declare function createAgentverseInsightsAdapter(options?: Hcs25AgentverseInsightsAdapterOptions): Hcs25AdapterDefinition;
+/**
+ * Creates the `agentverse-verifier` adapter: converts verifier interaction
+ * counters into a reliability score combining success rate, a response-time
+ * penalty, and a volume confidence factor. Conditional contribution keeps
+ * agents without verifier counters out of the denominator.
+ */
+export declare function createAgentverseVerifierAdapter(options?: Hcs25AgentverseVerifierAdapterOptions): Hcs25AdapterDefinition;
+//# sourceMappingURL=agentverse.d.ts.map

package/dist/browser-root/hcs-25/adapters/agentverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentverse.d.ts","sourceRoot":"","sources":["../../../../src/hcs-25/adapters/agentverse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sBAAsB,EAGvB,MAAM,UAAU,CAAC;AAQlB;;GAEG;AACH,MAAM,WAAW,qCAAqC;IACpD,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,qCAAqC;IACpD,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,2DAA2D;IAC3D,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AA2BD;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,qCAA0C,GAClD,sBAAsB,CAWxB;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,qCAA0C,GAClD,sBAAsB,CAoExB"}

package/dist/browser-root/hcs-25/adapters/availability.d.ts

@@ -0,0 +1,22 @@
+import { Hcs25AdapterDefinition } from '../types';
+/**
+ * Options for the availability adapter.
+ */
+export interface Hcs25AvailabilityAdapterOptions {
+    /**
+     * How to interpret `availabilityScore`. `auto` (the default) treats
+     * values up to and including one as a ratio and larger values as an
+     * already-normalized percent.
+     */
+    scoreScale?: 'ratio' | 'percent' | 'auto';
+    /** Recency window in minutes for last-seen decay. Defaults to 1440. */
+    recencyWindowMinutes?: number;
+    /** Registries where reachability is not meaningful. */
+    excludeRegistries?: readonly string[];
+}
+/**
+ * Creates the `availability` adapter: rewards reachable endpoints and
+ * penalizes long offline windows using a linear 24-hour recency decay.
+ */
+export declare function createAvailabilityAdapter(options?: Hcs25AvailabilityAdapterOptions): Hcs25AdapterDefinition;
+//# sourceMappingURL=availability.d.ts.map

package/dist/browser-root/hcs-25/adapters/availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../../../src/hcs-25/adapters/availability.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sBAAsB,EAGvB,MAAM,UAAU,CAAC;AAGlB;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1C,uEAAuE;IACvE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,uDAAuD;IACvD,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AA2CD;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,+BAAoC,GAC5C,sBAAsB,CAkBxB"}