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

package/dist/internal/contracts/projection.d.ts

@@ -0,0 +1,380 @@
+import { z } from 'zod';
+export declare const driveRelativePathSchema: z.ZodString;
+export declare const driveArtifactProjectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectionType: z.ZodLiteral<"GOOGLE_DRIVE">;
+    projectionId: z.ZodString;
+    relativePath: z.ZodString;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    identityRef: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNumber;
+    artifactKind: z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>;
+    artifactStatus: z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>;
+    artifactVersion: z.ZodNumber;
+}, z.core.$strict>;
+export declare const driveReviewPlaneProjectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectionType: z.ZodLiteral<"GOOGLE_DRIVE_REVIEW">;
+    projectionId: z.ZodString;
+    relativePath: z.ZodString;
+    workspaceRoot: z.ZodString;
+    reviewStage: z.ZodEnum<{
+        REVIEWED: "REVIEWED";
+        PROGRAM: "PROGRAM";
+        INBOX: "INBOX";
+        USER_APPROVED: "USER_APPROVED";
+        PROMOTION_RECEIPTS: "PROMOTION_RECEIPTS";
+        GUIDES: "GUIDES";
+        REJECTED_SUPERSEDED: "REJECTED_SUPERSEDED";
+    }>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    identityRef: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNumber;
+    artifactKind: z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>;
+    artifactStatus: z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>;
+    artifactVersion: z.ZodNumber;
+}, z.core.$strict>;
+export declare const driveUploadProjectionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectionType: z.ZodLiteral<"GOOGLE_DRIVE">;
+    projectionId: z.ZodString;
+    relativePath: z.ZodString;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    identityRef: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNumber;
+    artifactKind: z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>;
+    artifactStatus: z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>;
+    artifactVersion: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectionType: z.ZodLiteral<"GOOGLE_DRIVE_REVIEW">;
+    projectionId: z.ZodString;
+    relativePath: z.ZodString;
+    workspaceRoot: z.ZodString;
+    reviewStage: z.ZodEnum<{
+        REVIEWED: "REVIEWED";
+        PROGRAM: "PROGRAM";
+        INBOX: "INBOX";
+        USER_APPROVED: "USER_APPROVED";
+        PROMOTION_RECEIPTS: "PROMOTION_RECEIPTS";
+        GUIDES: "GUIDES";
+        REJECTED_SUPERSEDED: "REJECTED_SUPERSEDED";
+    }>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    identityRef: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNumber;
+    artifactKind: z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>;
+    artifactStatus: z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>;
+    artifactVersion: z.ZodNumber;
+}, z.core.$strict>]>;
+export declare const driveProviderIdSchema: z.ZodString;
+export declare const driveProviderDeliverySchema: z.ZodObject<{
+    provider: z.ZodLiteral<"GOOGLE_DRIVE">;
+    fileId: z.ZodString;
+    mimeType: z.ZodString;
+    byteLength: z.ZodNumber;
+    md5Checksum: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+    modifiedTime: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const driveDeliveryReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectionId: z.ZodString;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    contentHash: z.ZodString;
+    relativePath: z.ZodString;
+    deliveredAt: z.ZodISODateTime;
+    provider: z.ZodObject<{
+        provider: z.ZodLiteral<"GOOGLE_DRIVE">;
+        fileId: z.ZodString;
+        mimeType: z.ZodString;
+        byteLength: z.ZodNumber;
+        md5Checksum: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+        modifiedTime: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const driveUploadFolderBindingSchema: z.ZodObject<{
+    relativePath: z.ZodString;
+    name: z.ZodString;
+    parentFileId: z.ZodString;
+    fileId: z.ZodString;
+    disposition: z.ZodEnum<{
+        EXISTING: "EXISTING";
+        RESERVED: "RESERVED";
+    }>;
+}, z.core.$strict>;
+export declare const driveUploadFileBindingSchema: z.ZodObject<{
+    name: z.ZodString;
+    parentFileId: z.ZodString;
+    fileId: z.ZodString;
+    disposition: z.ZodEnum<{
+        EXISTING: "EXISTING";
+        RESERVED: "RESERVED";
+    }>;
+}, z.core.$strict>;
+export declare const driveUploadIntentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectionId: z.ZodString;
+    projectKey: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    contentHash: z.ZodString;
+    relativePath: z.ZodString;
+    rootParentFolderId: z.ZodString;
+    sharedDriveId: z.ZodNullable<z.ZodString>;
+    reservedAt: z.ZodISODateTime;
+    folders: z.ZodArray<z.ZodObject<{
+        relativePath: z.ZodString;
+        name: z.ZodString;
+        parentFileId: z.ZodString;
+        fileId: z.ZodString;
+        disposition: z.ZodEnum<{
+            EXISTING: "EXISTING";
+            RESERVED: "RESERVED";
+        }>;
+    }, z.core.$strict>>;
+    file: z.ZodObject<{
+        name: z.ZodString;
+        parentFileId: z.ZodString;
+        fileId: z.ZodString;
+        disposition: z.ZodEnum<{
+            EXISTING: "EXISTING";
+            RESERVED: "RESERVED";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const driveProjectionOutboxEntrySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    deliveryId: z.ZodString;
+    state: z.ZodEnum<{
+        PENDING: "PENDING";
+        BLOCKED: "BLOCKED";
+        DELIVERED: "DELIVERED";
+        FAILED_RETRYABLE: "FAILED_RETRYABLE";
+        FAILED_TERMINAL: "FAILED_TERMINAL";
+    }>;
+    projection: z.ZodUnion<readonly [z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        projectionType: z.ZodLiteral<"GOOGLE_DRIVE">;
+        projectionId: z.ZodString;
+        relativePath: z.ZodString;
+        projectKey: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        artifactRef: z.ZodString;
+        identityRef: z.ZodString;
+        contentHash: z.ZodString;
+        mediaType: z.ZodString;
+        byteLength: z.ZodNumber;
+        artifactKind: z.ZodEnum<{
+            SIGNAL_GENERATION: "SIGNAL_GENERATION";
+            RESEARCH: "RESEARCH";
+            REVIEW: "REVIEW";
+            KNOWLEDGE: "KNOWLEDGE";
+            INSIGHT: "INSIGHT";
+        }>;
+        artifactStatus: z.ZodEnum<{
+            GENERATED: "GENERATED";
+            DRAFT: "DRAFT";
+            READY_FOR_REVIEW: "READY_FOR_REVIEW";
+            REWORK_REQUIRED: "REWORK_REQUIRED";
+            APPROVED: "APPROVED";
+            REJECTED: "REJECTED";
+            SUPERSEDED: "SUPERSEDED";
+        }>;
+        artifactVersion: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        projectionType: z.ZodLiteral<"GOOGLE_DRIVE_REVIEW">;
+        projectionId: z.ZodString;
+        relativePath: z.ZodString;
+        workspaceRoot: z.ZodString;
+        reviewStage: z.ZodEnum<{
+            REVIEWED: "REVIEWED";
+            PROGRAM: "PROGRAM";
+            INBOX: "INBOX";
+            USER_APPROVED: "USER_APPROVED";
+            PROMOTION_RECEIPTS: "PROMOTION_RECEIPTS";
+            GUIDES: "GUIDES";
+            REJECTED_SUPERSEDED: "REJECTED_SUPERSEDED";
+        }>;
+        projectKey: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        artifactRef: z.ZodString;
+        identityRef: z.ZodString;
+        contentHash: z.ZodString;
+        mediaType: z.ZodString;
+        byteLength: z.ZodNumber;
+        artifactKind: z.ZodEnum<{
+            SIGNAL_GENERATION: "SIGNAL_GENERATION";
+            RESEARCH: "RESEARCH";
+            REVIEW: "REVIEW";
+            KNOWLEDGE: "KNOWLEDGE";
+            INSIGHT: "INSIGHT";
+        }>;
+        artifactStatus: z.ZodEnum<{
+            GENERATED: "GENERATED";
+            DRAFT: "DRAFT";
+            READY_FOR_REVIEW: "READY_FOR_REVIEW";
+            REWORK_REQUIRED: "REWORK_REQUIRED";
+            APPROVED: "APPROVED";
+            REJECTED: "REJECTED";
+            SUPERSEDED: "SUPERSEDED";
+        }>;
+        artifactVersion: z.ZodNumber;
+    }, z.core.$strict>]>;
+    outboxDirectory: z.ZodString;
+    descriptorPath: z.ZodString;
+    payloadPath: z.ZodString;
+    uploadIntentPath: z.ZodNullable<z.ZodString>;
+    uploadIntent: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        projectionId: z.ZodString;
+        projectKey: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        artifactRef: z.ZodString;
+        contentHash: z.ZodString;
+        relativePath: z.ZodString;
+        rootParentFolderId: z.ZodString;
+        sharedDriveId: z.ZodNullable<z.ZodString>;
+        reservedAt: z.ZodISODateTime;
+        folders: z.ZodArray<z.ZodObject<{
+            relativePath: z.ZodString;
+            name: z.ZodString;
+            parentFileId: z.ZodString;
+            fileId: z.ZodString;
+            disposition: z.ZodEnum<{
+                EXISTING: "EXISTING";
+                RESERVED: "RESERVED";
+            }>;
+        }, z.core.$strict>>;
+        file: z.ZodObject<{
+            name: z.ZodString;
+            parentFileId: z.ZodString;
+            fileId: z.ZodString;
+            disposition: z.ZodEnum<{
+                EXISTING: "EXISTING";
+                RESERVED: "RESERVED";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    deliveryPath: z.ZodNullable<z.ZodString>;
+    delivery: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        projectionId: z.ZodString;
+        projectKey: z.ZodString;
+        projectRef: z.ZodOptional<z.ZodString>;
+        artifactRef: z.ZodString;
+        contentHash: z.ZodString;
+        relativePath: z.ZodString;
+        deliveredAt: z.ZodISODateTime;
+        provider: z.ZodObject<{
+            provider: z.ZodLiteral<"GOOGLE_DRIVE">;
+            fileId: z.ZodString;
+            mimeType: z.ZodString;
+            byteLength: z.ZodNumber;
+            md5Checksum: z.ZodString;
+            version: z.ZodNullable<z.ZodString>;
+            modifiedTime: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const driveProjectionStagingReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    deliveryId: z.ZodString;
+    projectionId: z.ZodString;
+    projectRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodString;
+    contentHash: z.ZodString;
+    relativePath: z.ZodString;
+    runtimeNodeId: z.ZodString;
+    stagedAt: z.ZodISODateTime;
+    outboxDirectory: z.ZodString;
+    descriptorPath: z.ZodString;
+    payloadPath: z.ZodString;
+    reused: z.ZodBoolean;
+}, z.core.$strict>;
+export type DriveArtifactProjection = z.infer<typeof driveArtifactProjectionSchema>;
+export type DriveReviewPlaneProjection = z.infer<typeof driveReviewPlaneProjectionSchema>;
+export type DriveUploadProjection = z.infer<typeof driveUploadProjectionSchema>;
+export type DriveProviderDelivery = z.infer<typeof driveProviderDeliverySchema>;
+export type DriveUploadFolderBinding = z.infer<typeof driveUploadFolderBindingSchema>;
+export type DriveUploadFileBinding = z.infer<typeof driveUploadFileBindingSchema>;
+export type DriveUploadIntent = z.infer<typeof driveUploadIntentSchema>;
+export type DriveDeliveryReceipt = z.infer<typeof driveDeliveryReceiptSchema>;
+export type DriveProjectionStagingReceipt = z.infer<typeof driveProjectionStagingReceiptSchema>;
+export type DriveProjectionOutboxEntry = z.infer<typeof driveProjectionOutboxEntrySchema>;

package/dist/internal/contracts/projection.js

@@ -0,0 +1,194 @@
+import { z } from 'zod';
+import { artifactKindSchema, artifactStatusSchema } from './artifact.js';
+import { idSchema, isoDateTimeSchema, projectKeySchema, schemaVersionSchema, sha256Schema, stableUriSchema } from './common.js';
+export const driveRelativePathSchema = z.string().trim().min(1).max(2048).refine((value) => {
+    if (value.startsWith('/') || value.startsWith('\\'))
+        return false;
+    if (value.includes('\\'))
+        return false;
+    return !value.split('/').some((part) => !part || part === '.' || part === '..');
+}, 'Drive relative path must be normalized and traversal-free');
+export const driveArtifactProjectionSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectionType: z.literal('GOOGLE_DRIVE'),
+    projectionId: sha256Schema,
+    relativePath: driveRelativePathSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    artifactRef: stableUriSchema,
+    identityRef: stableUriSchema,
+    contentHash: sha256Schema,
+    mediaType: z.string().trim().min(1).max(256),
+    byteLength: z.number().int().nonnegative(),
+    artifactKind: artifactKindSchema,
+    artifactStatus: artifactStatusSchema,
+    artifactVersion: z.number().int().positive(),
+}).strict().superRefine((value, ctx) => {
+    if (!value.relativePath.startsWith(`Knowledge V2/${value.projectKey}/`))
+        ctx.addIssue({ code: 'custom', path: ['relativePath'], message: 'Drive path project must match projectKey' });
+    if (value.projectRef) {
+        try {
+            const project = new URL(value.projectRef);
+            if (project.protocol !== 'knowledge-project:' || project.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+                ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'projectRef project must match projectKey' });
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'Invalid projectRef' });
+        }
+    }
+    try {
+        const artifact = new URL(value.artifactRef);
+        const identity = new URL(value.identityRef);
+        if (artifact.hostname.toLowerCase() !== value.projectKey.toLowerCase() || identity.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+            ctx.addIssue({ code: 'custom', path: ['artifactRef'], message: 'Artifact refs must match projectKey' });
+    }
+    catch {
+        ctx.addIssue({ code: 'custom', path: ['artifactRef'], message: 'Artifact refs must be valid stable URLs' });
+    }
+});
+export const driveReviewPlaneProjectionSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectionType: z.literal('GOOGLE_DRIVE_REVIEW'),
+    projectionId: sha256Schema,
+    relativePath: driveRelativePathSchema,
+    workspaceRoot: driveRelativePathSchema,
+    reviewStage: z.enum(['PROGRAM', 'INBOX', 'REVIEWED', 'USER_APPROVED', 'PROMOTION_RECEIPTS', 'GUIDES', 'REJECTED_SUPERSEDED']),
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    artifactRef: stableUriSchema,
+    identityRef: stableUriSchema,
+    contentHash: sha256Schema,
+    mediaType: z.string().trim().min(1).max(256),
+    byteLength: z.number().int().nonnegative(),
+    artifactKind: artifactKindSchema,
+    artifactStatus: artifactStatusSchema,
+    artifactVersion: z.number().int().positive(),
+}).strict().superRefine((value, ctx) => {
+    if (!value.relativePath.startsWith(`${value.workspaceRoot}/`))
+        ctx.addIssue({ code: 'custom', path: ['relativePath'], message: 'Review projection path must stay under workspaceRoot' });
+    if (value.projectRef) {
+        try {
+            const project = new URL(value.projectRef);
+            if (project.protocol !== 'knowledge-project:' || project.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+                ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'projectRef project must match projectKey' });
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'Invalid projectRef' });
+        }
+    }
+    try {
+        const artifact = new URL(value.artifactRef);
+        const identity = new URL(value.identityRef);
+        if (artifact.hostname.toLowerCase() !== value.projectKey.toLowerCase() || identity.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+            ctx.addIssue({ code: 'custom', path: ['artifactRef'], message: 'Artifact refs must match projectKey' });
+    }
+    catch {
+        ctx.addIssue({ code: 'custom', path: ['artifactRef'], message: 'Artifact refs must be valid stable URLs' });
+    }
+});
+export const driveUploadProjectionSchema = z.union([driveArtifactProjectionSchema, driveReviewPlaneProjectionSchema]);
+export const driveProviderIdSchema = z.string().trim().regex(/^[A-Za-z0-9_-]{10,512}$/);
+export const driveProviderDeliverySchema = z.object({
+    provider: z.literal('GOOGLE_DRIVE'),
+    fileId: driveProviderIdSchema,
+    mimeType: z.string().trim().min(1).max(256),
+    byteLength: z.number().int().nonnegative(),
+    md5Checksum: z.string().regex(/^[a-f0-9]{32}$/),
+    version: z.string().trim().min(1).max(128).nullable(),
+    modifiedTime: isoDateTimeSchema.nullable(),
+}).strict();
+export const driveDeliveryReceiptSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectionId: sha256Schema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    artifactRef: stableUriSchema,
+    contentHash: sha256Schema,
+    relativePath: driveRelativePathSchema,
+    deliveredAt: isoDateTimeSchema,
+    provider: driveProviderDeliverySchema,
+}).strict().superRefine((value, ctx) => {
+    if (value.projectRef) {
+        try {
+            const project = new URL(value.projectRef);
+            if (project.protocol !== 'knowledge-project:' || project.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+                ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'projectRef project must match projectKey' });
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'Invalid projectRef' });
+        }
+    }
+});
+export const driveUploadFolderBindingSchema = z.object({
+    relativePath: driveRelativePathSchema,
+    name: z.string().trim().min(1).max(255),
+    parentFileId: driveProviderIdSchema,
+    fileId: driveProviderIdSchema,
+    disposition: z.enum(['EXISTING', 'RESERVED']),
+}).strict();
+export const driveUploadFileBindingSchema = z.object({
+    name: z.string().trim().min(1).max(255),
+    parentFileId: driveProviderIdSchema,
+    fileId: driveProviderIdSchema,
+    disposition: z.enum(['EXISTING', 'RESERVED']),
+}).strict();
+export const driveUploadIntentSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectionId: sha256Schema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    artifactRef: stableUriSchema,
+    contentHash: sha256Schema,
+    relativePath: driveRelativePathSchema,
+    rootParentFolderId: driveProviderIdSchema,
+    sharedDriveId: driveProviderIdSchema.nullable(),
+    reservedAt: isoDateTimeSchema,
+    folders: z.array(driveUploadFolderBindingSchema).max(32),
+    file: driveUploadFileBindingSchema,
+}).strict().superRefine((value, ctx) => {
+    if (value.projectRef) {
+        try {
+            const project = new URL(value.projectRef);
+            if (project.protocol !== 'knowledge-project:' || project.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+                ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'projectRef project must match projectKey' });
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'Invalid projectRef' });
+        }
+    }
+});
+export const driveProjectionOutboxEntrySchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    deliveryId: sha256Schema,
+    state: z.enum(['PENDING', 'DELIVERED', 'BLOCKED', 'FAILED_RETRYABLE', 'FAILED_TERMINAL']),
+    projection: driveUploadProjectionSchema,
+    outboxDirectory: z.string().trim().min(1).max(4096).startsWith('/'),
+    descriptorPath: z.string().trim().min(1).max(4096).startsWith('/'),
+    payloadPath: z.string().trim().min(1).max(4096).startsWith('/'),
+    uploadIntentPath: z.string().trim().min(1).max(4096).startsWith('/').nullable(),
+    uploadIntent: driveUploadIntentSchema.nullable(),
+    deliveryPath: z.string().trim().min(1).max(4096).startsWith('/').nullable(),
+    delivery: driveDeliveryReceiptSchema.nullable(),
+}).strict().superRefine((value, ctx) => {
+    if ((value.uploadIntentPath === null) !== (value.uploadIntent === null))
+        ctx.addIssue({ code: 'custom', path: ['uploadIntent'], message: 'upload intent path/value must appear together' });
+    if (value.state !== 'DELIVERED' && (value.deliveryPath !== null || value.delivery !== null))
+        ctx.addIssue({ code: 'custom', path: ['delivery'], message: 'Only DELIVERED entry may carry Drive provider delivery' });
+    if (value.state === 'DELIVERED' && (value.deliveryPath === null || value.delivery === null))
+        ctx.addIssue({ code: 'custom', path: ['delivery'], message: 'DELIVERED entry requires delivery' });
+});
+export const driveProjectionStagingReceiptSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    deliveryId: sha256Schema,
+    projectionId: sha256Schema,
+    projectRef: stableUriSchema.optional(),
+    artifactRef: stableUriSchema,
+    contentHash: sha256Schema,
+    relativePath: driveRelativePathSchema,
+    runtimeNodeId: idSchema,
+    stagedAt: isoDateTimeSchema,
+    outboxDirectory: z.string().trim().min(1).max(4096).startsWith('/'),
+    descriptorPath: z.string().trim().min(1).max(4096).startsWith('/'),
+    payloadPath: z.string().trim().min(1).max(4096).startsWith('/'),
+    reused: z.boolean(),
+}).strict();