@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/domain-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,33 @@
+export declare const DomainPayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<{
+    schema: "network.xyo.domain" & {
+        readonly __schema: true;
+    };
+    additional?: string[] | undefined;
+    aliases?: Record<string, {
+        huri: string;
+        name?: string | undefined;
+    }> | undefined;
+    networks?: {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    schemas?: Record<string, string | {
+        [x: string]: unknown;
+        $id?: string | undefined;
+    }> | undefined;
+}>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Resolution/DomainSchemaResolver.d.ts

@@ -0,0 +1,45 @@
+import type { Payload } from '../../../payload-model/neutral/index.ts';
+import type { SchemaPayload } from '../../../schema-payload-plugin/neutral/index.ts';
+import type { DomainConfigFields } from '../Payload.ts';
+import type { ResolveSchemaOptions, SchemaResolution, SchemaResolutionMechanism, SchemaResolutionSource } from './SchemaResolution.ts';
+interface ResolveContext {
+    /** at least one mechanism answered cleanly (NXDOMAIN, 404, config without the schema) */
+    anyCleanAnswer: boolean;
+    archivistUri?: string;
+    proxy?: string;
+    visited: Set<string>;
+}
+interface Resolved {
+    payload: SchemaPayload;
+    source: SchemaResolutionSource;
+}
+/**
+ * The candidate domains for a schema name, shortest first
+ * (com.example.foo -> example.com, foo.example.com). See SPEC.md §5.
+ */
+export declare function candidateDomains(schemaName: string): string[];
+/**
+ * Whether a schema name falls inside a domain's reverse-domain namespace: the name's
+ * leading levels, reversed, equal the domain or a parent of it. See SPEC.md §2.1.
+ */
+export declare function isSchemaInDomainNamespace(schemaName: string, domain: string): boolean;
+/**
+ * Resolves a schema name to the domain-published authoritative schema definition by
+ * walking the publication mechanisms in SPEC.md §5: DNS TXT records at _xyo.{domain}
+ * (per-schema, config hash, domain indirection, legacy bare hash), then the xyo.json
+ * root file, the xyo. subdomain index, and the legacy xyo-config.json (with the
+ * archivist proxy as browser fallback).
+ */
+export declare class DomainSchemaResolver {
+    resolve(schemaName: string, options?: ResolveSchemaOptions): Promise<SchemaResolution>;
+    /** Fetch a payload by hash (or HURI href) and verify it against the referenced hash */
+    protected fetchPayload(hashOrHref: string, context: ResolveContext, configFields?: DomainConfigFields): Promise<Payload | undefined>;
+    protected fetchSchemaPayloadByHash(hashOrHref: string, schemaName: string, context: ResolveContext, configFields?: DomainConfigFields): Promise<SchemaPayload | undefined>;
+    protected lookupHash(fields: DomainConfigFields, schemaName: string): string | undefined;
+    /** Find the schema in a domain config document (schemas map first, then legacy aliases) */
+    protected lookupInConfig(fields: DomainConfigFields | undefined, schemaName: string, domain: string, mechanism: SchemaResolutionMechanism, context: ResolveContext, url?: string): Promise<Resolved | undefined>;
+    protected resolveAtDomain(domain: string, schemaName: string, depth: number, context: ResolveContext): Promise<Resolved | undefined>;
+    protected resolveViaDns(domain: string, schemaName: string, depth: number, context: ResolveContext): Promise<Resolved | undefined>;
+}
+export {};
+//# sourceMappingURL=DomainSchemaResolver.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Resolution/SchemaResolution.d.ts

@@ -0,0 +1,27 @@
+import type { Hash } from '@xylabs/sdk';
+import type { SchemaPayload } from '../../../schema-payload-plugin/neutral/index.ts';
+/**
+ * How a schema definition was discovered. See SPEC.md §5.
+ */
+export type SchemaResolutionMechanism = 'dns-schema' | 'dns-config' | 'dns-domain' | 'dns-legacy' | 'file-root' | 'file-subdomain' | 'file-legacy' | 'file-proxy';
+export type SchemaResolutionStatus = 'resolved' | 'not-published' | 'unreachable';
+export interface SchemaResolutionSource {
+    domain: string;
+    hash?: Hash;
+    mechanism: SchemaResolutionMechanism;
+    url?: string;
+}
+export interface SchemaResolution {
+    payload?: SchemaPayload;
+    source?: SchemaResolutionSource;
+    status: SchemaResolutionStatus;
+}
+export interface ResolveSchemaOptions {
+    /** Archivist used to fetch payloads by hash; overrides config networks and the HURI default */
+    archivistUri?: string;
+    /** Maximum domain= indirection depth (default 3) */
+    maxIndirectionDepth?: number;
+    /** Archivist domain proxy used as a browser fallback for root-file fetches */
+    proxy?: string;
+}
+//# sourceMappingURL=SchemaResolution.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Resolution/XyoDnsRecords.d.ts

@@ -0,0 +1,27 @@
+import { type Hash } from '@xylabs/sdk';
+import type { GoogleDnsResultAnswer } from '../../../dns/neutral/index.ts';
+/**
+ * The parsed contents of the TXT record set at _xyo.{domain}. See SPEC.md §3.3.
+ */
+export interface XyoDnsRecords {
+    /** config={hash-or-huri} — hash of a network.xyo.domain.config (or legacy domain) payload */
+    config?: string;
+    /** domain={other-domain} — the named domain is the schema authority for this domain */
+    domain?: string;
+    /** bare 64-hex records — legacy hashes of network.xyo.domain payloads */
+    legacyHashes: Hash[];
+    /** schema.{name}={hash-or-huri} — per-schema hashes of network.xyo.schema payloads */
+    schemas: Record<string, string>;
+}
+/**
+ * Strip surrounding double quotes and join multi-string TXT data ("abc" "def" -> abcdef)
+ * before grammar matching, per SPEC.md §3.3.
+ */
+export declare function normalizeTxtData(data: string): string;
+/**
+ * Parse the TXT answers from a _xyo.{domain} query into the four record modes. Unknown
+ * keys are ignored; duplicates resolve lexicographically-first so results are
+ * deterministic regardless of DNS answer order.
+ */
+export declare function parseXyoTxtRecords(answers?: GoogleDnsResultAnswer[]): XyoDnsRecords;
+//# sourceMappingURL=XyoDnsRecords.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Resolution/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DomainSchemaResolver.ts';
+export * from './SchemaResolution.ts';
+export * from './XyoDnsRecords.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,5 @@
+export declare const DomainSchema: "network.xyo.domain" & {
+    readonly __schema: true;
+};
+export type DomainSchema = typeof DomainSchema;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,3 @@
+import type { DomainPayload } from './Payload.ts';
+export declare const domainConfigTemplate: () => DomainPayload;
+//# sourceMappingURL=Template.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/Wrapper.d.ts

@@ -0,0 +1,278 @@
+import { type Hash } from '@xylabs/sdk';
+import type { FetchedPayload } from '../../huri/neutral/index.ts';
+import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
+import type { DomainConfigPayload } from './DomainConfigPayload.ts';
+import { type Alias, type DomainPayload } from './Payload.ts';
+export interface FetchedAlias extends FetchedPayload {
+    alias: Alias;
+}
+export declare class DomainPayloadWrapper<T extends DomainPayload | DomainConfigPayload = DomainPayload> extends PayloadWrapper<T> {
+    aliases?: FetchedAlias[] | null;
+    static discover(reverseDomainName: string, proxy?: string): Promise<DomainPayloadWrapper<(import("../../payload-model/neutral/index.ts").PayloadFields & {
+        schema: import("../../payload-model/neutral/index.ts").Schema;
+    } & Partial<import("../../payload-model/neutral/index.ts").PayloadMetaFields> & {
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }) | (import("../../payload-model/neutral/index.ts").PayloadFields & {
+        schema: import("../../payload-model/neutral/index.ts").Schema;
+    } & Partial<import("../../payload-model/neutral/index.ts").PayloadMetaFields> & {
+        schema: "network.xyo.domain.config" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    })> | DomainPayloadWrapper<{
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }> | undefined>;
+    static discoverDNSEntry(domain: string): Promise<DomainPayloadWrapper<(import("../../payload-model/neutral/index.ts").PayloadFields & {
+        schema: import("../../payload-model/neutral/index.ts").Schema;
+    } & Partial<import("../../payload-model/neutral/index.ts").PayloadMetaFields> & {
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }) | (import("../../payload-model/neutral/index.ts").PayloadFields & {
+        schema: import("../../payload-model/neutral/index.ts").Schema;
+    } & Partial<import("../../payload-model/neutral/index.ts").PayloadMetaFields> & {
+        schema: "network.xyo.domain.config" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    })> | undefined>;
+    static discoverRootFile(domain: string, proxy?: string): Promise<DomainPayloadWrapper<{
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }> | undefined>;
+    static discoverRootFileDirect(domain: string): Promise<DomainPayloadWrapper<{
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }> | undefined>;
+    static discoverRootFileWithProxy(domain: string, proxy?: string): Promise<DomainPayloadWrapper<{
+        schema: "network.xyo.domain" & {
+            readonly __schema: true;
+        };
+        additional?: string[] | undefined;
+        aliases?: Record<string, {
+            huri: string;
+            name?: string | undefined;
+        }> | undefined;
+        networks?: {
+            schema: "network.xyo.network" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            name?: string | undefined;
+            nodes?: {
+                schema: "network.xyo.network.node" & {
+                    readonly __schema: true;
+                };
+                slug: string;
+                type: "archivist" | "diviner" | "bridge" | "sentinel";
+                uri: string;
+                docs?: string | undefined;
+                name?: string | undefined;
+                web?: string | undefined;
+            }[] | undefined;
+        }[] | undefined;
+        schemas?: Record<string, string | {
+            [x: string]: unknown;
+            $id?: string | undefined;
+        }> | undefined;
+    }> | undefined>;
+    private fetchAlias;
+    private findArchivistUri;
+    private getNetwork;
+    fetch(networkSlug?: Hash): Promise<void>;
+    fetchAliases(networkSlug?: Hash): Promise<void>;
+}
+//# sourceMappingURL=Wrapper.d.ts.map

package/dist/_pkg/domain-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,11 @@
+export * from './DomainConfigPayload.ts';
+export * from './DomainConfigPlugin.ts';
+export * from './DomainConfigSchema.ts';
+export * from './DomainConfigTemplate.ts';
+export * from './Payload.ts';
+export { DomainPayloadPlugin as default, DomainPayloadPlugin } from './Plugin.ts';
+export * from './Resolution/index.ts';
+export * from './Schema.ts';
+export * from './Template.ts';
+export * from './Wrapper.ts';
+//# sourceMappingURL=index.d.ts.map