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

package/dist/internal/serving-contracts/consumer.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { idSchema, isoDateTimeSchema, richDocumentSchema, schemaVersionSchema, sha256Schema, stableUriSchema } from '../contracts/index.js';
+import { referenceCorpusSummarySchema, referenceCurrentnessSchema, referenceRecordTypeSchema, referenceSelectorKeySchema, referenceSelectorValueSchema, servingCurrentnessSchema, servingDecisionSchema, servingEvidenceSummarySchema } from './core.js';
+export const consumerProjectRefSchema = stableUriSchema.superRefine((value, ctx) => { try {
+    const u = new URL(value);
+    if (u.protocol !== 'knowledge-project:' || !/^\/tenant\/[^/]+$/.test(u.pathname))
+        ctx.addIssue({ code: 'custom', message: 'projectRef must be a tenant-bound Knowledge project' });
+}
+catch {
+    ctx.addIssue({ code: 'custom', message: 'Invalid projectRef' });
+} });
+export const consumerResourceTypeSchema = z.enum(['artifact', 'evidence', 'reference', 'media']);
+export const consumerSearchInputSchema = z.object({ projectRef: consumerProjectRefSchema, query: z.string().trim().min(1).max(2000), limit: z.number().int().min(1).max(50).optional(), cursor: z.string().min(1).max(4096).optional() }).strict();
+// OAuth 消费者按项目关系发现 Evidence；下一页 ref 只决定位置，不携带授权。
+export const consumerEvidencePageInputSchema = z.object({ projectRef: consumerProjectRefSchema, sourceId: idSchema.optional(), after: stableUriSchema.optional(), limit: z.number().int().min(1).max(50).optional() }).strict();
+export const consumerEvidencePageResponseSchema = z.object({ schemaVersion: schemaVersionSchema, projectRef: consumerProjectRefSchema, decision: servingDecisionSchema, items: z.array(z.object({ decision: servingDecisionSchema, fileDecision: servingDecisionSchema, contentDecision: servingDecisionSchema, evidence: servingEvidenceSummarySchema }).strict()).max(50), nextAfter: stableUriSchema.nullable() }).strict();
+export const consumerReadInputSchema = z.object({ projectRef: consumerProjectRefSchema, ref: stableUriSchema }).strict();
+export const consumerCurrentnessInputSchema = consumerReadInputSchema;
+export const referenceLookupSelectorsSchema = z.record(referenceSelectorKeySchema, z.array(referenceSelectorValueSchema).min(1).max(32)).superRefine((value, ctx) => { const keys = Object.keys(value); if (keys.length > 32)
+    ctx.addIssue({ code: 'custom', message: 'Reference lookup selectors cannot exceed 32 keys' }); for (const key of keys) {
+    const values = value[key] ?? [];
+    if (new Set(values).size !== values.length)
+        ctx.addIssue({ code: 'custom', path: [key], message: 'Reference lookup selector values must be unique' });
+} });
+const referenceLookupFilterObjectSchema = z.object({ jurisdiction: z.string().trim().min(1).max(128).optional(), corpusKeys: z.array(z.string().trim().min(1).max(128)).min(1).max(32).optional(), recordTypes: z.array(referenceRecordTypeSchema).min(1).max(64).optional(), selectors: referenceLookupSelectorsSchema.optional(), effectiveAt: isoDateTimeSchema.optional(), limit: z.number().int().min(1).max(100).optional() }).strict();
+const requireLookupFilter = (value, ctx) => { if (!value.jurisdiction && !value.corpusKeys?.length && !value.recordTypes?.length && !value.selectors && !value.effectiveAt)
+    ctx.addIssue({ code: 'custom', message: 'Reference lookup requires at least one structured filter' }); };
+export const referenceLookupFilterSchema = referenceLookupFilterObjectSchema.superRefine(requireLookupFilter);
+export const consumerReferenceLookupInputSchema = referenceLookupFilterObjectSchema.extend({ projectRef: consumerProjectRefSchema }).superRefine(requireLookupFilter);
+export const consumerSearchItemSchema = z.object({
+    ref: stableUriSchema, resourceType: consumerResourceTypeSchema, title: z.string().max(1000).nullable(), summary: z.string().max(4000).nullable(), contentHash: sha256Schema,
+    sourceRefs: z.array(stableUriSchema).max(256), observedAt: isoDateTimeSchema.nullable(), validUntil: isoDateTimeSchema.nullable(), decision: servingDecisionSchema,
+}).strict();
+export const consumerSearchResponseSchema = z.object({ schemaVersion: schemaVersionSchema, projectRef: consumerProjectRefSchema, decision: servingDecisionSchema, searchCoverage: z.enum(['AUTHORIZED_METADATA_V1', 'AUTHORIZED_PRESENTATION_V1']), items: z.array(consumerSearchItemSchema).max(50), nextCursor: z.string().max(4096).nullable() }).strict();
+export const consumerContentDescriptorSchema = z.object({ contentHash: sha256Schema, mediaType: z.string().trim().min(1).max(256), byteLength: z.number().int().nonnegative() }).strict();
+export const consumerReadResponseSchema = z.object({
+    schemaVersion: schemaVersionSchema, projectRef: consumerProjectRefSchema, decision: servingDecisionSchema,
+    item: z.object({ ref: stableUriSchema, resourceType: consumerResourceTypeSchema, descriptor: consumerContentDescriptorSchema.nullable(), content: z.string().nullable(), encoding: z.enum(['utf8', 'base64']).nullable(), truncated: z.boolean(), continuation: z.object({ kind: z.literal('AUTHENTICATED_SERVING_CONTENT'), ref: stableUriSchema }).strict().nullable(), presentation: richDocumentSchema.nullable().optional() }).strict().nullable(),
+}).strict();
+export const consumerCurrentnessResponseSchema = z.object({
+    schemaVersion: schemaVersionSchema, projectRef: consumerProjectRefSchema, decision: servingDecisionSchema,
+    item: z.object({ ref: stableUriSchema, currentness: z.union([servingCurrentnessSchema, referenceCurrentnessSchema]) }).strict().nullable(),
+}).strict();
+export const consumerReferenceLookupItemSchema = z.object({ decision: servingDecisionSchema, summary: referenceCorpusSummarySchema, payloadDecision: servingDecisionSchema, payload: z.json().nullable() }).strict();
+export const consumerReferenceLookupResponseSchema = z.object({ schemaVersion: schemaVersionSchema, projectRef: consumerProjectRefSchema, decision: servingDecisionSchema, lookupCoverage: z.literal('AUTHORIZED_REFERENCE_SELECTORS_V1'), items: z.array(consumerReferenceLookupItemSchema).max(100) }).strict();

package/dist/internal/serving-contracts/core.d.ts

@@ -0,0 +1,333 @@
+import { referenceSelectorsSchema, referenceCorpusSummarySchema, referenceCorpusRecordSchema } from '../contracts/index.js';
+export { referenceRecordTypeSchema, referenceSelectorKeySchema, referenceSelectorValueSchema, referenceSelectorsSchema, referenceCurrentnessStateSchema, referenceCurrentnessSchema, referenceCorpusSummarySchema, referenceCorpusRecordSchema } from '../contracts/index.js';
+import { z } from 'zod';
+export declare const servingActionSchema: z.ZodEnum<{
+    ALLOW: "ALLOW";
+    REVIEW_REQUIRED: "REVIEW_REQUIRED";
+    DENY: "DENY";
+}>;
+export declare const servingProblemCodeSchema: z.ZodEnum<{
+    NOT_FOUND: "NOT_FOUND";
+    ACCESS_DENIED: "ACCESS_DENIED";
+    CONTENT_ACCESS_DENIED: "CONTENT_ACCESS_DENIED";
+    ARTIFACT_NOT_APPROVED: "ARTIFACT_NOT_APPROVED";
+    ARTIFACT_SUPERSEDED: "ARTIFACT_SUPERSEDED";
+    SEMANTIC_REVIEW_REQUIRED: "SEMANTIC_REVIEW_REQUIRED";
+    SEMANTIC_DENIED: "SEMANTIC_DENIED";
+    SEMANTIC_ADMISSION_MISSING: "SEMANTIC_ADMISSION_MISSING";
+    CURRENTNESS_MISSING: "CURRENTNESS_MISSING";
+    CURRENTNESS_REVIEW_REQUIRED: "CURRENTNESS_REVIEW_REQUIRED";
+    CURRENTNESS_DENIED: "CURRENTNESS_DENIED";
+    STALE: "STALE";
+    VALIDITY_EXPIRED: "VALIDITY_EXPIRED";
+    CLAIM_REVIEW_REQUIRED: "CLAIM_REVIEW_REQUIRED";
+    CLAIM_DENIED: "CLAIM_DENIED";
+    CLAIM_NOT_EFFECTIVE: "CLAIM_NOT_EFFECTIVE";
+    REFERENCE_NOT_COVERED: "REFERENCE_NOT_COVERED";
+    REFERENCE_NOT_EFFECTIVE: "REFERENCE_NOT_EFFECTIVE";
+    REFERENCE_VALIDITY_EXPIRED: "REFERENCE_VALIDITY_EXPIRED";
+    REFERENCE_STALE: "REFERENCE_STALE";
+    REFERENCE_UNAVAILABLE: "REFERENCE_UNAVAILABLE";
+    REFERENCE_REVIEW_REQUIRED: "REFERENCE_REVIEW_REQUIRED";
+    REFERENCE_DENIED: "REFERENCE_DENIED";
+    UNSUPPORTED_RESOURCE: "UNSUPPORTED_RESOURCE";
+    GOVERNANCE_NOT_CONFIGURED: "GOVERNANCE_NOT_CONFIGURED";
+    UNAVAILABLE: "UNAVAILABLE";
+    INTEGRITY_MISMATCH: "INTEGRITY_MISMATCH";
+}>;
+export declare const servingDecisionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    action: z.ZodEnum<{
+        ALLOW: "ALLOW";
+        REVIEW_REQUIRED: "REVIEW_REQUIRED";
+        DENY: "DENY";
+    }>;
+    reasonCodes: z.ZodArray<z.ZodEnum<{
+        NOT_FOUND: "NOT_FOUND";
+        ACCESS_DENIED: "ACCESS_DENIED";
+        CONTENT_ACCESS_DENIED: "CONTENT_ACCESS_DENIED";
+        ARTIFACT_NOT_APPROVED: "ARTIFACT_NOT_APPROVED";
+        ARTIFACT_SUPERSEDED: "ARTIFACT_SUPERSEDED";
+        SEMANTIC_REVIEW_REQUIRED: "SEMANTIC_REVIEW_REQUIRED";
+        SEMANTIC_DENIED: "SEMANTIC_DENIED";
+        SEMANTIC_ADMISSION_MISSING: "SEMANTIC_ADMISSION_MISSING";
+        CURRENTNESS_MISSING: "CURRENTNESS_MISSING";
+        CURRENTNESS_REVIEW_REQUIRED: "CURRENTNESS_REVIEW_REQUIRED";
+        CURRENTNESS_DENIED: "CURRENTNESS_DENIED";
+        STALE: "STALE";
+        VALIDITY_EXPIRED: "VALIDITY_EXPIRED";
+        CLAIM_REVIEW_REQUIRED: "CLAIM_REVIEW_REQUIRED";
+        CLAIM_DENIED: "CLAIM_DENIED";
+        CLAIM_NOT_EFFECTIVE: "CLAIM_NOT_EFFECTIVE";
+        REFERENCE_NOT_COVERED: "REFERENCE_NOT_COVERED";
+        REFERENCE_NOT_EFFECTIVE: "REFERENCE_NOT_EFFECTIVE";
+        REFERENCE_VALIDITY_EXPIRED: "REFERENCE_VALIDITY_EXPIRED";
+        REFERENCE_STALE: "REFERENCE_STALE";
+        REFERENCE_UNAVAILABLE: "REFERENCE_UNAVAILABLE";
+        REFERENCE_REVIEW_REQUIRED: "REFERENCE_REVIEW_REQUIRED";
+        REFERENCE_DENIED: "REFERENCE_DENIED";
+        UNSUPPORTED_RESOURCE: "UNSUPPORTED_RESOURCE";
+        GOVERNANCE_NOT_CONFIGURED: "GOVERNANCE_NOT_CONFIGURED";
+        UNAVAILABLE: "UNAVAILABLE";
+        INTEGRITY_MISMATCH: "INTEGRITY_MISMATCH";
+    }>>;
+    assessedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const consumerProfileSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    consumerKey: z.ZodString;
+    acceptedArtifactKinds: z.ZodArray<z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>>;
+    acceptedAccess: z.ZodArray<z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>>;
+    contentAccess: z.ZodArray<z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>>;
+    acceptedReferenceTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const servingContentDescriptorSchema: z.ZodObject<{
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNumber;
+}, z.core.$strict>;
+export declare const servingArtifactSummarySchema: z.ZodObject<{
+    ref: z.ZodString;
+    identityRef: z.ZodString;
+    projectKey: z.ZodString;
+    projectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    artifactId: z.ZodString;
+    kind: z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    title: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    observedAt: z.ZodNullable<z.ZodISODateTime>;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+    content: z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const servingArtifactDetailSchema: z.ZodObject<{
+    ref: z.ZodString;
+    identityRef: z.ZodString;
+    projectKey: z.ZodString;
+    projectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    artifactId: z.ZodString;
+    kind: z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    title: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    observedAt: z.ZodNullable<z.ZodISODateTime>;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+    content: z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    relatedRefs: z.ZodArray<z.ZodString>;
+    supersedesRef: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const servingEvidenceSummarySchema: z.ZodObject<{
+    evidenceRef: z.ZodString;
+    projectKey: z.ZodString;
+    sourceId: z.ZodString;
+    contentHash: z.ZodString;
+    observedAt: z.ZodISODateTime;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    canonicalUri: z.ZodNullable<z.ZodString>;
+    mediaType: z.ZodNullable<z.ZodString>;
+    byteLength: z.ZodNullable<z.ZodNumber>;
+    projectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sourceSetRef: z.ZodNullable<z.ZodString>;
+    sourceItemId: z.ZodNullable<z.ZodString>;
+    sourceRevisionRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    collectionBatchRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    collectionTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const servingSourceSummarySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    authority: z.ZodString;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    freshness: z.ZodString;
+    declaredState: z.ZodString;
+    coverageState: z.ZodNullable<z.ZodString>;
+    asOf: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const servingProjectIntentSummarySchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    projectRef: z.ZodString;
+    tenantId: z.ZodString;
+    revisionRef: z.ZodString;
+    projectName: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const servingProjectSourceSummarySchema: z.ZodObject<{
+    projectKey: z.ZodString;
+    projectRef: z.ZodString;
+    projectIntentRef: z.ZodNullable<z.ZodString>;
+    sourceId: z.ZodString;
+    sourceRef: z.ZodString;
+    sourceRevisionRef: z.ZodString;
+    targetId: z.ZodString;
+    targetKind: z.ZodEnum<{
+        URL: "URL";
+        FILE: "FILE";
+        EXECUTOR: "EXECUTOR";
+    }>;
+    locator: z.ZodString;
+    executorId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodBoolean;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    refreshMode: z.ZodEnum<{
+        MANUAL: "MANUAL";
+        INTERVAL: "INTERVAL";
+    }>;
+    intervalSeconds: z.ZodNullable<z.ZodNumber>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const servingGovernanceSourceSummarySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    authority: z.ZodString;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    freshness: z.ZodString;
+    declaredState: z.ZodString;
+    coverageState: z.ZodNullable<z.ZodString>;
+    asOf: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const servingCurrentnessSchema: z.ZodObject<{
+    subjectRef: z.ZodString;
+    projectRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sourceRevisionRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    state: z.ZodEnum<{
+        UNKNOWN: "UNKNOWN";
+        DUE: "DUE";
+        CURRENT: "CURRENT";
+        STALE: "STALE";
+        BLOCKED: "BLOCKED";
+    }>;
+    action: z.ZodEnum<{
+        ALLOW: "ALLOW";
+        REVIEW_REQUIRED: "REVIEW_REQUIRED";
+        DENY: "DENY";
+    }>;
+    assessedAt: z.ZodISODateTime;
+    dueAt: z.ZodNullable<z.ZodISODateTime>;
+    staleAt: z.ZodNullable<z.ZodISODateTime>;
+    reasonCode: z.ZodString;
+}, z.core.$strict>;
+export type ServingAction = z.infer<typeof servingActionSchema>;
+export type ServingProblemCode = z.infer<typeof servingProblemCodeSchema>;
+export type ServingDecision = z.infer<typeof servingDecisionSchema>;
+export type ConsumerProfile = z.infer<typeof consumerProfileSchema>;
+export type ServingArtifactSummary = z.infer<typeof servingArtifactSummarySchema>;
+export type ServingArtifactDetail = z.infer<typeof servingArtifactDetailSchema>;
+export type ServingEvidenceSummary = z.infer<typeof servingEvidenceSummarySchema>;
+export type ServingSourceSummary = z.infer<typeof servingSourceSummarySchema>;
+export type ServingProjectIntentSummary = z.infer<typeof servingProjectIntentSummarySchema>;
+export type ServingProjectSourceSummary = z.infer<typeof servingProjectSourceSummarySchema>;
+export type ServingCurrentness = z.infer<typeof servingCurrentnessSchema>;
+export type ReferenceSelectors = z.infer<typeof referenceSelectorsSchema>;
+export type ReferenceCorpusSummary = z.infer<typeof referenceCorpusSummarySchema>;
+export type ReferenceCorpusRecord = z.infer<typeof referenceCorpusRecordSchema>;

package/dist/internal/serving-contracts/core.js

@@ -0,0 +1,76 @@
+// Compatibility exports: immutable Reference facts are owned by contracts.
+import { referenceRecordTypeSchema, referenceSelectorKeySchema, referenceSelectorValueSchema, referenceSelectorsSchema, referenceCurrentnessStateSchema, referenceCurrentnessSchema, referenceCorpusSummarySchema, referenceCorpusRecordSchema } from '../contracts/index.js';
+export { referenceRecordTypeSchema, referenceSelectorKeySchema, referenceSelectorValueSchema, referenceSelectorsSchema, referenceCurrentnessStateSchema, referenceCurrentnessSchema, referenceCorpusSummarySchema, referenceCorpusRecordSchema } from '../contracts/index.js';
+import { z } from 'zod';
+import { accessClassificationSchema, artifactKindSchema, artifactStatusSchema, currentnessActionSchema, currentnessStateSchema, idSchema, isoDateTimeSchema, projectKeySchema, schemaVersionSchema, sha256Schema, stableUriSchema, } from '../contracts/index.js';
+export const servingActionSchema = z.enum(['ALLOW', 'REVIEW_REQUIRED', 'DENY']);
+export const servingProblemCodeSchema = z.enum([
+    'NOT_FOUND', 'ACCESS_DENIED', 'CONTENT_ACCESS_DENIED', 'ARTIFACT_NOT_APPROVED', 'ARTIFACT_SUPERSEDED',
+    'SEMANTIC_REVIEW_REQUIRED', 'SEMANTIC_DENIED', 'SEMANTIC_ADMISSION_MISSING',
+    'CURRENTNESS_MISSING', 'CURRENTNESS_REVIEW_REQUIRED', 'CURRENTNESS_DENIED', 'STALE', 'VALIDITY_EXPIRED',
+    'CLAIM_REVIEW_REQUIRED', 'CLAIM_DENIED', 'CLAIM_NOT_EFFECTIVE',
+    'REFERENCE_NOT_COVERED', 'REFERENCE_NOT_EFFECTIVE', 'REFERENCE_VALIDITY_EXPIRED', 'REFERENCE_STALE', 'REFERENCE_UNAVAILABLE', 'REFERENCE_REVIEW_REQUIRED', 'REFERENCE_DENIED',
+    'UNSUPPORTED_RESOURCE', 'GOVERNANCE_NOT_CONFIGURED', 'UNAVAILABLE', 'INTEGRITY_MISMATCH',
+]);
+export const servingDecisionSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    action: servingActionSchema,
+    reasonCodes: z.array(servingProblemCodeSchema).max(32),
+    assessedAt: isoDateTimeSchema,
+}).strict().superRefine((value, ctx) => {
+    if (value.action === 'ALLOW' && value.reasonCodes.length)
+        ctx.addIssue({ code: 'custom', path: ['reasonCodes'], message: 'ALLOW must not carry problem codes' });
+    if (value.action !== 'ALLOW' && !value.reasonCodes.length)
+        ctx.addIssue({ code: 'custom', path: ['reasonCodes'], message: 'Non-ALLOW decision requires a problem code' });
+});
+export const consumerProfileSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    consumerKey: projectKeySchema,
+    acceptedArtifactKinds: z.array(artifactKindSchema).max(16),
+    acceptedAccess: z.array(accessClassificationSchema).max(7),
+    contentAccess: z.array(accessClassificationSchema).max(7),
+    acceptedReferenceTypes: z.array(referenceRecordTypeSchema).max(128),
+}).strict().superRefine((value, ctx) => {
+    if (new Set(value.acceptedArtifactKinds).size !== value.acceptedArtifactKinds.length)
+        ctx.addIssue({ code: 'custom', path: ['acceptedArtifactKinds'], message: 'acceptedArtifactKinds must be unique' });
+    if (new Set(value.acceptedAccess).size !== value.acceptedAccess.length)
+        ctx.addIssue({ code: 'custom', path: ['acceptedAccess'], message: 'acceptedAccess must be unique' });
+    if (new Set(value.contentAccess).size !== value.contentAccess.length)
+        ctx.addIssue({ code: 'custom', path: ['contentAccess'], message: 'contentAccess must be unique' });
+    if (value.contentAccess.some((access) => !value.acceptedAccess.includes(access)))
+        ctx.addIssue({ code: 'custom', path: ['contentAccess'], message: 'contentAccess must be a subset of acceptedAccess' });
+    if (value.contentAccess.some((access) => ['PUBLIC_METADATA', 'ACCESS_CONTROLLED', 'UNKNOWN'].includes(access)))
+        ctx.addIssue({ code: 'custom', path: ['contentAccess'], message: 'Metadata-only, access-controlled and unknown classes cannot grant content access' });
+    if (new Set(value.acceptedReferenceTypes).size !== value.acceptedReferenceTypes.length)
+        ctx.addIssue({ code: 'custom', path: ['acceptedReferenceTypes'], message: 'acceptedReferenceTypes must be unique' });
+});
+export const servingContentDescriptorSchema = z.object({
+    contentHash: sha256Schema, mediaType: z.string().trim().min(1).max(256), byteLength: z.number().int().nonnegative(),
+}).strict();
+export const servingArtifactSummarySchema = z.object({
+    ref: stableUriSchema, identityRef: stableUriSchema, projectKey: projectKeySchema, projectRef: stableUriSchema.nullable().default(null), artifactId: idSchema, kind: artifactKindSchema,
+    version: z.number().int().positive(), status: artifactStatusSchema, access: accessClassificationSchema, title: z.string().max(500).nullable(),
+    createdAt: isoDateTimeSchema, observedAt: isoDateTimeSchema.nullable(), validUntil: isoDateTimeSchema.nullable(), content: servingContentDescriptorSchema,
+}).strict();
+export const servingArtifactDetailSchema = servingArtifactSummarySchema.extend({
+    evidenceRefs: z.array(stableUriSchema).max(256), relatedRefs: z.array(stableUriSchema).max(256), supersedesRef: stableUriSchema.nullable(),
+}).strict();
+export const servingEvidenceSummarySchema = z.object({
+    evidenceRef: stableUriSchema, projectKey: projectKeySchema, sourceId: idSchema, contentHash: sha256Schema, observedAt: isoDateTimeSchema,
+    access: accessClassificationSchema, canonicalUri: stableUriSchema.nullable(), mediaType: z.string().max(256).nullable(), byteLength: z.number().int().nonnegative().nullable(),
+    projectRef: stableUriSchema.nullable().default(null), sourceSetRef: stableUriSchema.nullable(), sourceItemId: idSchema.nullable(), sourceRevisionRef: stableUriSchema.nullable().default(null), collectionBatchRef: stableUriSchema.nullable().default(null), collectionTaskId: idSchema.nullable().default(null),
+}).strict();
+export const servingSourceSummarySchema = z.object({
+    sourceId: idSchema, familyId: idSchema, authority: z.string().min(1).max(512), access: accessClassificationSchema, freshness: z.string().min(1).max(128),
+    declaredState: z.string().min(1).max(128), coverageState: z.string().max(128).nullable(), asOf: isoDateTimeSchema,
+}).strict();
+export const servingProjectIntentSummarySchema = z.object({
+    projectKey: projectKeySchema, projectRef: stableUriSchema, tenantId: idSchema, revisionRef: stableUriSchema, projectName: z.string().trim().min(1).max(256), updatedAt: isoDateTimeSchema,
+}).strict();
+export const servingProjectSourceSummarySchema = z.object({
+    projectKey: projectKeySchema, projectRef: stableUriSchema, projectIntentRef: stableUriSchema.nullable(), sourceId: idSchema, sourceRef: stableUriSchema, sourceRevisionRef: stableUriSchema, targetId: sha256Schema, targetKind: z.enum(['URL', 'FILE', 'EXECUTOR']), locator: stableUriSchema, executorId: idSchema.nullable().default(null), enabled: z.boolean(), access: accessClassificationSchema, refreshMode: z.enum(['MANUAL', 'INTERVAL']), intervalSeconds: z.number().int().min(60).nullable(), updatedAt: isoDateTimeSchema,
+}).strict();
+export const servingGovernanceSourceSummarySchema = servingSourceSummarySchema;
+export const servingCurrentnessSchema = z.object({
+    subjectRef: stableUriSchema, projectRef: stableUriSchema.nullable().default(null), sourceRevisionRef: stableUriSchema.nullable().default(null), state: currentnessStateSchema, action: currentnessActionSchema, assessedAt: isoDateTimeSchema, dueAt: isoDateTimeSchema.nullable(), staleAt: isoDateTimeSchema.nullable(), reasonCode: z.string().min(1).max(128),
+}).strict();