@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.2

package/dist/internal/contracts/tenant-web-collection.js

@@ -0,0 +1,118 @@
+/** Tenant 网站采集意图；范围和内容要求不携带 Project 或执行权限。 */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { isoDateTimeSchema, sha256Schema } from './common.js';
+import { materialTenantIdSchema } from './material-context.js';
+import { tenantStorageKey } from './resource-scope.js';
+import { knowledgeActorContextSchema } from './project-intent.js';
+import { isTenantSourceCredentialParameter } from './tenant-source.js';
+import { tenantCollectionCycleSchema, tenantCollectionMaxBytesSchema } from './tenant-collection.js';
+import { tenantCollectionRequestAuthoritySchema } from './tenant-collection-request.js';
+export const TENANT_WEB_SPEC_CAPABILITY = 'TENANT_WEB_COLLECTION_SPEC_V1';
+export const tenantWebUrlSchema = z.string().url().max(2048).superRefine((raw, ctx) => {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        ctx.addIssue({ code: 'custom', message: 'A valid HTTP URL is required' });
+        return;
+    }
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash || url.port || [...url.searchParams.keys()].some(isTenantSourceCredentialParameter))
+        ctx.addIssue({ code: 'custom', message: 'Public HTTP URL without credentials, nonstandard port or fragment required' });
+});
+const originSchema = tenantWebUrlSchema.superRefine((value, ctx) => { try {
+    if (new URL(value).origin === value)
+        return;
+}
+catch { /* Report a schema issue, never an arbitrary URL parser error. */ } ctx.addIssue({ code: 'custom', message: 'An exact HTTP origin is required' }); });
+const pathSchema = z.string().min(1).max(512).superRefine((value, ctx) => {
+    let decoded = '';
+    try {
+        decoded = decodeURIComponent(value);
+    }
+    catch { /* Invalid encoding fails closed below. */ }
+    if (!decoded.startsWith('/') || decoded.startsWith('//') || /[?#\\\x00-\x1f]/.test(decoded) || decoded.split('/').some(part => part === '.' || part === '..') || decoded.replace(/\/\*\*$/, '').includes('*'))
+        ctx.addIssue({ code: 'custom', message: 'Absolute path or terminal /** prefix required' });
+});
+export const tenantWebScopeSchema = z.object({
+    mode: z.enum(['SINGLE_PAGE', 'URL_LIST', 'SITE_SECTION', 'SITEMAP', 'FEED']),
+    allowedOrigins: z.array(originSchema).max(16).default([]),
+    includePaths: z.array(pathSchema).max(32).default([]),
+    excludePaths: z.array(pathSchema).max(32).default([]),
+    urls: z.array(tenantWebUrlSchema).max(64).default([]),
+    followPagination: z.boolean().default(false),
+    followDetailLinks: z.boolean().default(false),
+}).strict();
+const field = z.object({ name: z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/), type: z.enum(['string', 'number', 'boolean', 'object', 'array']), required: z.boolean().default(false) }).strict();
+export const tenantWebRequirementsSchema = z.object({
+    instruction: z.string().trim().min(1).max(4000),
+    fields: z.array(field).max(64).default([]),
+    outputs: z.array(z.enum(['RAW', 'DOCUMENT', 'RECORDS'])).min(1).max(3).default(['RAW', 'DOCUMENT']),
+    attachments: z.array(z.enum(['PDF', 'IMAGE', 'AUDIO', 'VIDEO', 'OTHER'])).max(5).default([]),
+}).strict().superRefine((value, ctx) => { if (new Set(value.fields.map(f => f.name)).size !== value.fields.length)
+    ctx.addIssue({ code: 'custom', message: 'Field names must be unique' }); });
+export const tenantWebDefaultLimits = { maxPages: 100, maxDepth: 3, maxResourceBytes: 16 * 1024 * 1024, maxTotalBytes: 64 * 1024 * 1024, maxRuntimeMs: 300000, maxInteractions: 100, maxFiles: 100 };
+export const tenantWebLimitsSchema = z.object({
+    maxPages: z.number().int().min(1).max(10000).default(100),
+    maxDepth: z.number().int().min(0).max(10).default(3),
+    maxResourceBytes: tenantCollectionMaxBytesSchema.default(16 * 1024 * 1024),
+    maxTotalBytes: z.number().int().min(1024).max(1024 * 1024 * 1024).default(64 * 1024 * 1024),
+    maxRuntimeMs: z.number().int().min(1000).max(900000).default(300000),
+    maxInteractions: z.number().int().min(0).max(1000).default(100),
+    maxFiles: z.number().int().min(0).max(1000).default(100),
+}).strict();
+export const tenantWebSpecSchema = z.object({
+    schemaVersion: z.literal(1), url: tenantWebUrlSchema, scope: tenantWebScopeSchema,
+    requirements: tenantWebRequirementsSchema, limits: tenantWebLimitsSchema.default(tenantWebDefaultLimits),
+    refresh: z.object({ mode: z.literal('ONCE') }).strict().default({ mode: 'ONCE' }),
+}).strict().superRefine((value, ctx) => {
+    try {
+        const origins = value.scope.allowedOrigins.length ? value.scope.allowedOrigins : [new URL(value.url).origin];
+        if (!origins.includes(new URL(value.url).origin) || value.scope.urls.some(url => !origins.includes(new URL(url).origin)))
+            ctx.addIssue({ code: 'custom', path: ['scope'], message: 'Entry and explicit targets must remain in the declared origins' });
+    }
+    catch {
+        ctx.addIssue({ code: 'custom', path: ['scope'], message: 'Valid entry and target URLs are required' });
+    }
+    if ((value.scope.mode === 'URL_LIST') !== (value.scope.urls.length > 0))
+        ctx.addIssue({ code: 'custom', path: ['scope', 'urls'], message: 'Only URL_LIST requires explicit URLs' });
+    if (value.scope.mode === 'SITE_SECTION' && value.scope.includePaths.length === 0)
+        ctx.addIssue({ code: 'custom', path: ['scope', 'includePaths'], message: 'A site section requires an explicit path boundary' });
+    if (value.scope.mode === 'SINGLE_PAGE' && (value.scope.followPagination || value.scope.followDetailLinks))
+        ctx.addIssue({ code: 'custom', path: ['scope'], message: 'Single page cannot enable discovery' });
+});
+export function tenantWebCanonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return '[' + value.map(tenantWebCanonical).join(',') + ']';
+    const row = value;
+    return '{' + Object.keys(row).filter(key => row[key] !== undefined).sort().map(key => JSON.stringify(key) + ':' + tenantWebCanonical(row[key])).join(',') + '}';
+}
+const hash = (value) => createHash('sha256').update(tenantWebCanonical(value)).digest('hex');
+export function tenantWebSpecRevision(spec) { return 'sha256:' + hash(tenantWebSpecSchema.parse(spec)); }
+export function tenantWebRequestKey(requestId) { return hash(tenantCollectionCycleSchema.parse(requestId)); }
+export function tenantWebJobRef(tenantId, requestId) { return `tenant-web-collection://${tenantStorageKey(tenantId)}/${tenantWebRequestKey(requestId)}`; }
+export const tenantWebJobRefSchema = z.string().regex(/^tenant-web-collection:\/\/[a-f0-9]{64}\/[a-f0-9]{64}$/);
+export const tenantWebIntentSchema = z.object({
+    schemaVersion: z.literal(1), tenantId: materialTenantIdSchema, requestId: tenantCollectionCycleSchema,
+    jobRef: tenantWebJobRefSchema, inputRevision: sha256Schema, specRevision: sha256Schema, requestedSpec: tenantWebSpecSchema, spec: tenantWebSpecSchema,
+    actor: knowledgeActorContextSchema, authority: tenantCollectionRequestAuthoritySchema, submittedAt: isoDateTimeSchema,
+}).strict().superRefine((value, ctx) => {
+    if (value.actor.tenantId !== value.tenantId || value.jobRef !== tenantWebJobRef(value.tenantId, value.requestId) || value.specRevision !== tenantWebSpecRevision(value.spec) || value.inputRevision !== tenantWebSpecRevision(value.requestedSpec))
+        ctx.addIssue({ code: 'custom', message: 'Intent must preserve exact Tenant and frozen specification identity' });
+    if (value.spec.limits.maxResourceBytes > Math.min(value.requestedSpec.limits.maxResourceBytes, value.requestedSpec.limits.maxTotalBytes) || tenantWebCanonical({ ...value.spec, limits: { ...value.spec.limits, maxResourceBytes: value.requestedSpec.limits.maxResourceBytes } }) !== tenantWebCanonical(value.requestedSpec))
+        ctx.addIssue({ code: 'custom', message: 'Intake may only narrow the resource byte limit' });
+});
+/** S1 仅证明意图持久化；不制造待采列表、原件、时效或准入成功。 */
+export const tenantWebSummarySchema = z.object({
+    requestId: tenantCollectionCycleSchema, jobRef: tenantWebJobRefSchema, specRevision: sha256Schema, submittedAt: isoDateTimeSchema,
+    phase: z.literal('WEB_INTENT_PERSISTED'), state: z.literal('ACCEPTED'), execution: z.literal('UNAVAILABLE'),
+    reason: z.literal('S2_NOT_IMPLEMENTED'), completion: z.null(), networkValidated: z.literal(false), budgetReserved: z.literal(false),
+    requirementsState: z.literal('DECLARED_NOT_EVALUATED'),
+    coverage: z.object({ state: z.literal('NOT_STARTED'), total: z.null(), discovered: z.literal(0), acquired: z.literal(0), extracted: z.literal(0), registered: z.literal(0) }).strict(),
+}).strict().superRefine((value, ctx) => {
+    if (new URL(value.jobRef).pathname !== `/${tenantWebRequestKey(value.requestId)}`)
+        ctx.addIssue({ code: 'custom', message: 'Summary request identity must match its exact intent reference' });
+});

package/dist/internal/contracts/tenant-web-content-plan.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { tenantWebRequirementsSchema } from './tenant-web-collection.js';
+export declare const TENANT_WEB_CONTENT_CAPABILITY = "TENANT_WEB_CONTENT_V1";
+export declare const TENANT_WEB_CONTENT_EXTRACTOR: {
+    readonly id: "native-knowledge.web-content";
+    readonly version: "1.0.0";
+};
+export declare const tenantWebContentSelectorSchema: z.ZodString;
+export declare const tenantWebContentPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    compiler: z.ZodEnum<{
+        CALLER_PLAN_V1: "CALLER_PLAN_V1";
+        BOUNDED_LANGUAGE_V1: "BOUNDED_LANGUAGE_V1";
+    }>;
+    extractor: z.ZodObject<{
+        id: z.ZodLiteral<"native-knowledge.web-content">;
+        version: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>;
+    body: z.ZodBoolean;
+    tables: z.ZodBoolean;
+    links: z.ZodBoolean;
+    recordSelector: z.ZodNullable<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        selector: z.ZodString;
+        value: z.ZodDefault<z.ZodEnum<{
+            TEXT: "TEXT";
+            JSON: "JSON";
+            ATTRIBUTE: "ATTRIBUTE";
+        }>>;
+        attribute: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            datetime: "datetime";
+            value: "value";
+            title: "title";
+            href: "href";
+            alt: "alt";
+            content: "content";
+            src: "src";
+        }>>>;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    maxRecords: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type TenantWebContentPlan = z.infer<typeof tenantWebContentPlanSchema>;
+export declare const tenantWebContentInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"NATURAL_LANGUAGE">;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"COMPILED">;
+    extractor: z.ZodDefault<z.ZodObject<{
+        id: z.ZodLiteral<"native-knowledge.web-content">;
+        version: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>>;
+    body: z.ZodDefault<z.ZodBoolean>;
+    tables: z.ZodDefault<z.ZodBoolean>;
+    links: z.ZodDefault<z.ZodBoolean>;
+    recordSelector: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        selector: z.ZodString;
+        value: z.ZodDefault<z.ZodEnum<{
+            TEXT: "TEXT";
+            JSON: "JSON";
+            ATTRIBUTE: "ATTRIBUTE";
+        }>>;
+        attribute: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            datetime: "datetime";
+            value: "value";
+            title: "title";
+            href: "href";
+            alt: "alt";
+            content: "content";
+            src: "src";
+        }>>>;
+    }, z.core.$strict>>>;
+    maxRecords: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>], "mode">;
+export type TenantWebContentInput = z.input<typeof tenantWebContentInputSchema>;
+export declare function compileTenantWebContent(requirements: z.infer<typeof tenantWebRequirementsSchema>, raw: unknown): TenantWebContentPlan;
+export declare const tenantWebContentRevision: (plan: TenantWebContentPlan) => string;

package/dist/internal/contracts/tenant-web-content-plan.js

@@ -0,0 +1,39 @@
+/** Read-only extraction plans; no executable selectors, scripts, prompts or authority. */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { tenantWebCanonical, tenantWebRequirementsSchema } from './tenant-web-collection.js';
+export const TENANT_WEB_CONTENT_CAPABILITY = 'TENANT_WEB_CONTENT_V1';
+export const TENANT_WEB_CONTENT_EXTRACTOR = { id: 'native-knowledge.web-content', version: '1.0.0' };
+// A deliberately bounded CSS subset: compound tag/id/classes, descendant and child only.
+const atom = '(?:[A-Za-z][A-Za-z0-9_-]*|\\*)?(?:[.#][A-Za-z_][A-Za-z0-9_-]*)*';
+export const tenantWebContentSelectorSchema = z.string().trim().min(1).max(256).refine(s => s.split(/\s*>\s*|\s+/).length <= 8 && new RegExp('^' + atom + '(?:\\s*>\\s*' + atom + '|\\s+' + atom + ')*$').test(s) && s.split(/\s*>\s*|\s+/).every(Boolean), 'Unsupported read-only selector').describe('Read-only CSS subset: tag/id/classes, descendant or child (>) only; max 8 segments, no pseudos or scripts');
+const rule = z.object({ name: z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/), selector: tenantWebContentSelectorSchema, value: z.enum(['TEXT', 'ATTRIBUTE', 'JSON']).default('TEXT'), attribute: z.enum(['href', 'src', 'content', 'datetime', 'value', 'title', 'alt']).nullable().default(null) }).strict().refine(v => (v.value === 'ATTRIBUTE') === (v.attribute !== null));
+export const tenantWebContentPlanSchema = z.object({ schemaVersion: z.literal(1), compiler: z.enum(['CALLER_PLAN_V1', 'BOUNDED_LANGUAGE_V1']), extractor: z.object({ id: z.literal('native-knowledge.web-content'), version: z.literal('1.0.0') }).strict(), body: z.boolean(), tables: z.boolean(), links: z.boolean(), recordSelector: tenantWebContentSelectorSchema.nullable(), fields: z.array(z.object({ ...tenantWebRequirementsSchema.shape.fields.unwrap().element.shape, ...rule.shape })).max(64), maxRecords: z.number().int().min(1).max(100).default(50) }).strict().superRefine((v, c) => { if (v.fields.some(f => (f.value === 'ATTRIBUTE') !== (f.attribute !== null)) || new Set(v.fields.map(f => f.name)).size !== v.fields.length)
+    c.addIssue({ code: 'custom', message: 'Invalid field rule' }); });
+export const tenantWebContentInputSchema = z.discriminatedUnion('mode', [z.object({ mode: z.literal('NATURAL_LANGUAGE') }).strict(), z.object({ mode: z.literal('COMPILED'), extractor: z.object({ id: z.literal('native-knowledge.web-content'), version: z.literal('1.0.0') }).strict().default(TENANT_WEB_CONTENT_EXTRACTOR), body: z.boolean().default(false), tables: z.boolean().default(false), links: z.boolean().default(false), recordSelector: tenantWebContentSelectorSchema.nullable().default(null), fields: z.array(rule).max(64).default([]), maxRecords: z.number().int().min(1).max(100).default(50) }).strict()]).describe('NATURAL_LANGUAGE supports bounded body/tables/links combinations in Chinese or English. Otherwise provide COMPILED rules; no model calls.');
+export function compileTenantWebContent(requirements, raw) {
+    const input = tenantWebContentInputSchema.parse(raw);
+    let body = false, tables = false, links = false;
+    if (input.mode === 'NATURAL_LANGUAGE') {
+        const words = requirements.instruction.toLowerCase().replace(/^(?:请)?(?:采集|提取|获取|collect|extract)\s*/, '').split(/\s*(?:、|，|,|和|及|与|\band\b)\s*/).map(w => w.trim()).filter(Boolean);
+        for (const word of words) {
+            if (['正文', 'body', 'text', 'body text'].includes(word))
+                body = true;
+            else if (['表格', 'tables', 'table'].includes(word))
+                tables = true;
+            else if (['链接', 'links'].includes(word))
+                links = true;
+            else
+                throw new Error('TENANT_WEB_SEMANTIC_COMPILER_UNAVAILABLE');
+        }
+        if (!words.length || requirements.fields.length)
+            throw new Error('TENANT_WEB_SEMANTIC_COMPILER_UNAVAILABLE');
+    }
+    const rules = input.mode === 'COMPILED' ? input.fields : [];
+    if (rules.length !== requirements.fields.length || rules.some(f => !requirements.fields.some(v => v.name === f.name)))
+        throw new Error('TENANT_WEB_CONTENT_FIELD_PLAN_REQUIRED');
+    if (requirements.outputs.includes('RECORDS') && !requirements.fields.length)
+        throw new Error('TENANT_WEB_CONTENT_FIELD_PLAN_REQUIRED');
+    return tenantWebContentPlanSchema.parse({ schemaVersion: 1, compiler: input.mode === 'COMPILED' ? 'CALLER_PLAN_V1' : 'BOUNDED_LANGUAGE_V1', extractor: TENANT_WEB_CONTENT_EXTRACTOR, body: input.mode === 'COMPILED' ? input.body : body, tables: input.mode === 'COMPILED' ? input.tables : tables, links: input.mode === 'COMPILED' ? input.links : links, recordSelector: input.mode === 'COMPILED' ? input.recordSelector : null, fields: requirements.fields.map(f => ({ ...f, ...rules.find(r => r.name === f.name) })), maxRecords: input.mode === 'COMPILED' ? input.maxRecords : 50 });
+}
+export const tenantWebContentRevision = (plan) => 'sha256:' + createHash('sha256').update(tenantWebCanonical(tenantWebContentPlanSchema.parse(plan))).digest('hex');

package/dist/internal/contracts/tenant-web-content-result.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+export declare const TENANT_WEB_CONTENT_MEDIA_TYPE = "application/vnd.knowledge-v2.tenant-web-content+json";
+export declare const tenantWebContentDocumentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    format: z.ZodLiteral<"TENANT_WEB_CONTENT_V1">;
+    tenantId: z.ZodString;
+    jobRef: z.ZodString;
+    planRevision: z.ZodString;
+    extractor: z.ZodObject<{
+        id: z.ZodLiteral<"native-knowledge.web-content">;
+        version: z.ZodLiteral<"1.0.0">;
+    }, z.core.$strict>;
+    dependencies: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    propagation: z.ZodLiteral<"TENANT_ONLY">;
+    reviewState: z.ZodLiteral<"UNREVIEWED">;
+    parentEvidenceRef: z.ZodString;
+    sourceContentHash: z.ZodString;
+    sourceByteLength: z.ZodNumber;
+    sourceMediaType: z.ZodString;
+    sourceUri: z.ZodString;
+    observedAt: z.ZodISODateTime;
+    extractedAt: z.ZodISODateTime;
+    outputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            MISSING: "MISSING";
+            UNSUPPORTED: "UNSUPPORTED";
+            PRESENT: "PRESENT";
+        }>;
+        value: z.ZodNullable<z.ZodJSONSchema>;
+        citations: z.ZodArray<z.ZodObject<{
+            evidenceRef: z.ZodString;
+            contentHash: z.ZodString;
+            locator: z.ZodString;
+            excerpt: z.ZodString;
+        }, z.core.$strict>>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    records: z.ZodArray<z.ZodObject<{
+        ordinal: z.ZodNumber;
+        fields: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            state: z.ZodEnum<{
+                MISSING: "MISSING";
+                UNSUPPORTED: "UNSUPPORTED";
+                PRESENT: "PRESENT";
+            }>;
+            value: z.ZodNullable<z.ZodJSONSchema>;
+            citations: z.ZodArray<z.ZodObject<{
+                evidenceRef: z.ZodString;
+                contentHash: z.ZodString;
+                locator: z.ZodString;
+                excerpt: z.ZodString;
+            }, z.core.$strict>>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    gaps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TenantWebContentDocument = z.infer<typeof tenantWebContentDocumentSchema>;

package/dist/internal/contracts/tenant-web-content-result.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { isoDateTimeSchema, sha256Schema } from './common.js';
+import { materialTenantIdSchema } from './material-context.js';
+import { tenantResourceRefSchema, parseTenantResourceRef, tenantStorageKey } from './resource-scope.js';
+import { tenantWebJobRefSchema, tenantWebUrlSchema } from './tenant-web-collection.js';
+import { tenantWebFieldResultSchema } from './tenant-web-results.js';
+import { TENANT_WEB_CONTENT_EXTRACTOR } from './tenant-web-content-plan.js';
+export const TENANT_WEB_CONTENT_MEDIA_TYPE = 'application/vnd.knowledge-v2.tenant-web-content+json';
+export const tenantWebContentDocumentSchema = z.object({ schemaVersion: z.literal(1), format: z.literal('TENANT_WEB_CONTENT_V1'), tenantId: materialTenantIdSchema, jobRef: tenantWebJobRefSchema, planRevision: sha256Schema, extractor: z.object({ id: z.literal(TENANT_WEB_CONTENT_EXTRACTOR.id), version: z.literal(TENANT_WEB_CONTENT_EXTRACTOR.version) }).strict(), dependencies: z.array(z.object({ id: z.string().min(1).max(128), version: z.string().min(1).max(64) }).strict()).min(1).max(8), propagation: z.literal('TENANT_ONLY'), reviewState: z.literal('UNREVIEWED'), parentEvidenceRef: tenantResourceRefSchema, sourceContentHash: sha256Schema, sourceByteLength: z.number().int().nonnegative(), sourceMediaType: z.string().min(1).max(256), sourceUri: tenantWebUrlSchema, observedAt: isoDateTimeSchema, extractedAt: isoDateTimeSchema, outputs: z.array(tenantWebFieldResultSchema).max(4), records: z.array(z.object({ ordinal: z.number().int().min(0).max(99), fields: z.array(tenantWebFieldResultSchema).max(64) }).strict()).max(100), gaps: z.array(z.string().regex(/^[A-Z][A-Z0-9_]{0,127}$/)).max(32) }).strict().superRefine((v, c) => {
+    const key = tenantStorageKey(v.tenantId), parent = parseTenantResourceRef(v.parentEvidenceRef);
+    if (parent?.storageKey !== key || parent.resourceType !== 'evidence' || new URL(v.jobRef).hostname !== key || [...v.outputs, ...v.records.flatMap(r => r.fields)].some(f => f.citations.some(cite => cite.evidenceRef !== v.parentEvidenceRef || cite.contentHash !== v.sourceContentHash)))
+        c.addIssue({ code: 'custom', message: 'Content must cite its exact Tenant original' });
+    if (v.records.some((r, i) => r.ordinal !== i))
+        c.addIssue({ code: 'custom', message: 'Record order must be exact' });
+});