@gencow/core 0.1.27 → 0.1.29

package/dist/http-action.d.ts

@@ -0,0 +1,77 @@
+import type { GencowCtx } from "./context.js";
+/** httpAction 핸들러 — Hono 대신 Request/Response 타입으로 full HTTP 제어. */
+export type HttpActionHandler = (ctx: GencowCtx, req: HttpActionRequest) => Promise<HttpActionResponse>;
+export interface HttpActionRequest {
+    /** HTTP method (GET, POST, PUT, DELETE, PATCH) */
+    method: string;
+    /** Full URL */
+    url: string;
+    /** URL path (e.g. /api/cli/auth-start) */
+    path: string;
+    /** Route params (e.g. { id: "abc" } for /api/apps/:id) */
+    params: Record<string, string>;
+    /** Query string params */
+    query: Record<string, string>;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Parse JSON body */
+    json: <T = unknown>() => Promise<T>;
+    /** Parse form data */
+    formData: () => Promise<FormData>;
+    /** Raw body as ArrayBuffer */
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    /** Raw body as text */
+    text: () => Promise<string>;
+}
+export interface HttpActionResponse {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+/** httpAction 정의. 커스텀 HTTP 엔드포인트를 선언적으로 등록. */
+export interface HttpActionDef {
+    /** HTTP method */
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    /** URL path (Hono 패턴 — /api/cli/:code 형태 지원) */
+    path: string;
+    /** true = 인증 없이 접근 가능, false(기본) = auth 필수 */
+    isPublic: boolean;
+    /** 핸들러 */
+    handler: HttpActionHandler;
+}
+declare global {
+    var __gencow_httpActionRegistry: HttpActionDef[];
+}
+export declare const httpActionRegistry: HttpActionDef[];
+/**
+ * 커스텀 HTTP 엔드포인트를 선언적으로 등록합니다.
+ * query/mutation은 RPC 패턴이지만, httpAction은 RESTful HTTP 라우트를 직접 정의합니다.
+ *
+ * 사용 사례:
+ *   - CLI Device Auth (POST /api/cli/auth-start)
+ *   - 파일 업로드 (POST /api/apps/:id/deploy)
+ *   - Webhook 수신
+ *   - 외부 서비스 콜백
+ *
+ * @example
+ * ```typescript
+ * import { httpAction } from "@gencow/core";
+ *
+ * export const authStart = httpAction({
+ *     method: "POST",
+ *     path: "/api/cli/auth-start",
+ *     public: true,
+ *     handler: async (ctx, req) => {
+ *         const code = crypto.randomUUID().slice(0, 8);
+ *         return { body: { code, url: `https://gencow.com/cli-auth?code=${code}` } };
+ *     },
+ * });
+ * ```
+ */
+export declare function httpAction(def: {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    public?: boolean;
+    handler: HttpActionHandler;
+}): HttpActionDef;
+export declare function getRegisteredHttpActions(): HttpActionDef[];

package/dist/http-action.js

@@ -0,0 +1,41 @@
+if (!globalThis.__gencow_httpActionRegistry)
+    globalThis.__gencow_httpActionRegistry = [];
+export const httpActionRegistry = globalThis.__gencow_httpActionRegistry;
+/**
+ * 커스텀 HTTP 엔드포인트를 선언적으로 등록합니다.
+ * query/mutation은 RPC 패턴이지만, httpAction은 RESTful HTTP 라우트를 직접 정의합니다.
+ *
+ * 사용 사례:
+ *   - CLI Device Auth (POST /api/cli/auth-start)
+ *   - 파일 업로드 (POST /api/apps/:id/deploy)
+ *   - Webhook 수신
+ *   - 외부 서비스 콜백
+ *
+ * @example
+ * ```typescript
+ * import { httpAction } from "@gencow/core";
+ *
+ * export const authStart = httpAction({
+ *     method: "POST",
+ *     path: "/api/cli/auth-start",
+ *     public: true,
+ *     handler: async (ctx, req) => {
+ *         const code = crypto.randomUUID().slice(0, 8);
+ *         return { body: { code, url: `https://gencow.com/cli-auth?code=${code}` } };
+ *     },
+ * });
+ * ```
+ */
+export function httpAction(def) {
+    const actionDef = {
+        method: def.method,
+        path: def.path,
+        isPublic: def.public === true,
+        handler: def.handler,
+    };
+    httpActionRegistry.push(actionDef);
+    return actionDef;
+}
+export function getRegisteredHttpActions() {
+    return [...httpActionRegistry];
+}

package/dist/index.d.ts

@@ -4,9 +4,31 @@
  * Provides: query, mutation, storage, scheduler, auth
  * All with Convex-compatible DX patterns.
  */
-export type { GencowCtx, AuthCtx, UserIdentity, QueryDef, MutationDef, RealtimeCtx, HttpActionDef, HttpActionRequest, HttpActionResponse, HttpActionHandler, AIContext, AIMessage, AIResult, } from "./reactive.js";
-export { query, mutation, httpAction, buildRealtimeCtx, subscribe, unsubscribe, registerClient, deregisterClient, handleWsMessage, getQueryHandler, getQueryDef, getRegisteredQueries, getRegisteredMutations, getRegisteredHttpActions, } from "./reactive.js";
-export type { Storage } from "./storage.js";
+export type { GencowCtx, AuthCtx, UserIdentity, RealtimeCtx, RealtimeNotifyEvent, AIContext, AIMessage, AIResult, } from "./context.js";
+export { defineApi } from "./context.js";
+export type { QueryDef } from "./reactive-query-types.js";
+export type { MutationDef } from "./reactive-mutation-types.js";
+export type { HttpActionDef, HttpActionRequest, HttpActionResponse, HttpActionHandler, } from "./http-action.js";
+export type { SearchPrimitive, SearchScope, SearchFilter, SearchOptions, VectorSearchOptions, HybridSearchOptions, SearchHit, SearchResponse, SearchTierConfig, } from "./search-types.js";
+export type { DocumentVisibility, DocumentConvertMode, DocumentConvertProvider, DocumentResolvedProvider, DocumentConvertInput, DocumentPage, DocumentSection, DocumentProviderTrace, DocumentConvertResult, DocumentCacheArtifact, DocumentCacheKeyInput, GencowServicesCtx, WorkflowDocumentServicesCtx, } from "./document-types.js";
+export { buildDocumentCacheKey } from "./document-types.js";
+export type { WakeAppBootFailedResult, WakeAppDeferredResult, WakeAppDeferredStatus, WakeAppResult, WakeAppSuccessResult, WakeAppSuccessStatus, } from "./wake-app-result.js";
+export { DEFAULT_WAKE_RETRY_AFTER_SEC, buildWakeAppBootFailedResult, buildWakeAppSuccessResult, isWakeAppDeferredResult, } from "./wake-app-result.js";
+export type { PlatformCapacityPreset, PlatformCapacityProfileName } from "./platform-capacity-profile.js";
+export { PLATFORM_CAPACITY_ENV_KEYS, PLATFORM_CAPACITY_PRESETS, PLATFORM_CAPACITY_PROFILE_ENV, detectPlatformCapacityProfile, resolvePlatformCapacityPreset, } from "./platform-capacity-profile.js";
+export type { RagIngestReindexMode, RagIngestInput, RagIngestWorkflowArgs, RagIngestStartResult, RagIngestJobStatus, RagIngestJobRecord, } from "./rag-ingest-types.js";
+export type { CitationCoverage, ClaimSupportStatus, GroundedAnswerMode, Citation, ClaimEvidenceMap, GroundedAnswer, GroundingBudget, GroundedClaimInput, GroundedCompareInput, GroundedTopicInput, GroundedAnswerInput, GroundingRuntime, } from "./grounded-answer-types.js";
+export { DEFAULT_GROUNDING_BUDGET } from "./grounded-answer-types.js";
+export type { RagOperationKind, RagOperationMetricUnit, RagIndexHealth, RagOperationMetric, RagOperationsSummary, RagEvaluationExpectedClaim, RagEvaluationFixture, RagEvaluationFixtureResult, RagEvaluationRunResult, RagReindexMode, RagReindexPlan, } from "./rag-operations-types.js";
+export { ragCorpora, ragSources, ragSections, ragChunks, ragIngestJobs, ragOperationMetrics, } from "./rag-schema.js";
+export { buildQuerySubscriptionKey, subscriptionKeyMatchesQueryKey } from "./reactive-realtime.js";
+export { query, getQueryHandler, getQueryDef, getRegisteredQueries } from "./reactive-query.js";
+export { mutation, getRegisteredMutations } from "./reactive-mutation.js";
+export { procQuery, procMutation } from "./procedure.js";
+export type { GencowProcedureBuilder, GencowProcedureDef, GencowProcedureMiddleware, GencowProcedureHandler, } from "./procedure.js";
+export { httpAction, getRegisteredHttpActions } from "./http-action.js";
+export { subscribe, unsubscribe, registerClient, deregisterClient, buildRealtimeCtx, handleWsMessage, } from "./reactive-realtime.js";
+export type { Storage, StoredFile } from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";
 export type { Scheduler, ScheduleOptions, FailedJob, CreateSchedulerOptions, ScheduledJobRecord, } from "./scheduler.js";
 export { workflow, getWorkflowDef, getRegisteredWorkflows, getWorkflowResumeActionName, getWorkflowRealtimeKey, createWorkflowRealtimeToken, serializeWorkflowValue, deserializeWorkflowValue, parseWorkflowDurationMs, DEFAULT_WORKFLOW_MAX_DURATION_MS, DEFAULT_WORKFLOW_MAX_RETRIES, WORKFLOW_RESUME_ACTION_PREFIX, WORKFLOW_REALTIME_KEY_PREFIX, } from "./workflow.js";
@@ -17,14 +39,17 @@ export { v, parseArgs, GencowValidationError } from "./v.js";
 export type { Validator, Infer, InferArgs } from "./v.js";
 export { withRetry } from "./retry.js";
 export type { RetryOptions } from "./retry.js";
+export { filterTenantRuntimeEnvVars, isReservedTenantRuntimeEnvKey } from "./runtime-env-policy.js";
 export { cronJobs } from "./crons.js";
 export type { CronJobsBuilder, CronJobDef, IntervalOptions, DailyOptions, WeeklyOptions } from "./crons.js";
 export { defineAuth } from "./auth-config.js";
-export type { GencowAuthConfig, AuthEmailVerification } from "./auth-config.js";
+export type { GencowAuthConfig, AuthEmailVerification, AuthPasswordReset, AuthEvents, AuthHookContext, AuthUserLike, AuthOAuthConfig, SocialProviderConfig, SocialProvidersConfig, KakaoConfig, NaverConfig, CustomOAuthProvider, OAuthUserInfo, } from "./auth-config.js";
+export { defineConfig } from "./config.js";
+export type { GencowConfig, GencowDbConfig, GencowDeployConfig } from "./config.js";
 export { ownerRls, getOwnerRlsMeta, registerOwnerRls } from "./rls.js";
 export type { OwnerRlsMeta } from "./rls.js";
 export { createRlsDb } from "./rls-db.js";
 export type { RlsSessionContext } from "./rls-db.js";
-export { crud, parseFilterNode, applyFilterOp, getOwnerRlsTables, getRegisteredCrudCodegenMeta } from "./crud.js";
+export { crud, parseFilterNode, applyFilterOp, getOwnerRlsTables, getRegisteredCrudCodegenMeta, } from "./crud.js";
 export type { CrudCodegenMeta } from "./crud.js";
 export { crud as gencowCrud } from "./crud.js";

package/dist/index.js

@@ -4,18 +4,31 @@
  * Provides: query, mutation, storage, scheduler, auth
  * All with Convex-compatible DX patterns.
  */
-export { query, mutation, httpAction, buildRealtimeCtx, subscribe, unsubscribe, registerClient, deregisterClient, handleWsMessage, getQueryHandler, getQueryDef, getRegisteredQueries, getRegisteredMutations, getRegisteredHttpActions, } from "./reactive.js";
+export { defineApi } from "./context.js";
+export { buildDocumentCacheKey } from "./document-types.js";
+export { DEFAULT_WAKE_RETRY_AFTER_SEC, buildWakeAppBootFailedResult, buildWakeAppSuccessResult, isWakeAppDeferredResult, } from "./wake-app-result.js";
+export { PLATFORM_CAPACITY_ENV_KEYS, PLATFORM_CAPACITY_PRESETS, PLATFORM_CAPACITY_PROFILE_ENV, detectPlatformCapacityProfile, resolvePlatformCapacityPreset, } from "./platform-capacity-profile.js";
+export { DEFAULT_GROUNDING_BUDGET } from "./grounded-answer-types.js";
+export { ragCorpora, ragSources, ragSections, ragChunks, ragIngestJobs, ragOperationMetrics, } from "./rag-schema.js";
+export { buildQuerySubscriptionKey, subscriptionKeyMatchesQueryKey } from "./reactive-realtime.js";
+export { query, getQueryHandler, getQueryDef, getRegisteredQueries } from "./reactive-query.js";
+export { mutation, getRegisteredMutations } from "./reactive-mutation.js";
+export { procQuery, procMutation } from "./procedure.js";
+export { httpAction, getRegisteredHttpActions } from "./http-action.js";
+export { subscribe, unsubscribe, registerClient, deregisterClient, buildRealtimeCtx, handleWsMessage, } from "./reactive-realtime.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";
 export { workflow, getWorkflowDef, getRegisteredWorkflows, getWorkflowResumeActionName, getWorkflowRealtimeKey, createWorkflowRealtimeToken, serializeWorkflowValue, deserializeWorkflowValue, parseWorkflowDurationMs, DEFAULT_WORKFLOW_MAX_DURATION_MS, DEFAULT_WORKFLOW_MAX_RETRIES, WORKFLOW_RESUME_ACTION_PREFIX, WORKFLOW_REALTIME_KEY_PREFIX, } from "./workflow.js";
 export { deriveWorkflowStatus } from "./workflow-types.js";
 export { loadWorkflowSnapshot } from "./workflows-api.js";
 export { v, parseArgs, GencowValidationError } from "./v.js";
 export { withRetry } from "./retry.js";
+export { filterTenantRuntimeEnvVars, isReservedTenantRuntimeEnvKey } from "./runtime-env-policy.js";
 export { cronJobs } from "./crons.js";
 export { defineAuth } from "./auth-config.js";
+export { defineConfig } from "./config.js";
 // ─── RLS + CRUD Factory ───────────
 export { ownerRls, getOwnerRlsMeta, registerOwnerRls } from "./rls.js";
 export { createRlsDb } from "./rls-db.js";
-export { crud, parseFilterNode, applyFilterOp, getOwnerRlsTables, getRegisteredCrudCodegenMeta } from "./crud.js";
+export { crud, parseFilterNode, applyFilterOp, getOwnerRlsTables, getRegisteredCrudCodegenMeta, } from "./crud.js";
 // Deprecated alias — 하위호환용, 향후 메이저 버전에서 제거 예정
 export { crud as gencowCrud } from "./crud.js";

package/dist/platform-capacity-profile.d.ts

@@ -0,0 +1,19 @@
+export type PlatformCapacityProfileName = "prod" | "dev" | "local";
+export interface PlatformCapacityPreset {
+    profile: PlatformCapacityProfileName;
+    maxConcurrentRunning: number | null;
+    maxConcurrentWake: number | null;
+    maxWakeQueueMs: number;
+    minAvailableRamMB: number | null;
+    evictionThresholdMB: number | null;
+    sleepTimeoutMinutes: number;
+    sleepMaxPerCycle: number;
+    warmPoolMinIdle: number;
+    warmPoolMax: number;
+    deployCandidateReserve: number;
+}
+export declare const PLATFORM_CAPACITY_PROFILE_ENV = "GENCOW_CAPACITY_PROFILE";
+export declare const PLATFORM_CAPACITY_ENV_KEYS: readonly ["GENCOW_CAPACITY_PROFILE", "MAX_CONCURRENT_RUNNING", "MAX_CONCURRENT_WAKE", "MAX_WAKE_QUEUE_MS", "MIN_AVAILABLE_RAM_MB", "WAKE_RETRY_AFTER_SEC", "EVICTION_THRESHOLD_MB", "GENCOW_SLEEP_TIMEOUT_MINUTES", "GENCOW_SLEEP_MAX_PER_CYCLE", "WARM_POOL_MIN_IDLE", "WARM_POOL_MAX", "DEPLOY_CANDIDATE_RESERVE", "GENCOW_APP_PORT_RANGE", "COWBOX_WARM_POOL_PORT_RANGE"];
+export declare const PLATFORM_CAPACITY_PRESETS: Record<PlatformCapacityProfileName, PlatformCapacityPreset>;
+export declare function detectPlatformCapacityProfile(env?: Record<string, string | undefined>): PlatformCapacityProfileName;
+export declare function resolvePlatformCapacityPreset(env?: Record<string, string | undefined>): PlatformCapacityPreset;

package/dist/platform-capacity-profile.js

@@ -0,0 +1,94 @@
+export const PLATFORM_CAPACITY_PROFILE_ENV = "GENCOW_CAPACITY_PROFILE";
+export const PLATFORM_CAPACITY_ENV_KEYS = [
+    PLATFORM_CAPACITY_PROFILE_ENV,
+    "MAX_CONCURRENT_RUNNING",
+    "MAX_CONCURRENT_WAKE",
+    "MAX_WAKE_QUEUE_MS",
+    "MIN_AVAILABLE_RAM_MB",
+    "WAKE_RETRY_AFTER_SEC",
+    "EVICTION_THRESHOLD_MB",
+    "GENCOW_SLEEP_TIMEOUT_MINUTES",
+    "GENCOW_SLEEP_MAX_PER_CYCLE",
+    "WARM_POOL_MIN_IDLE",
+    "WARM_POOL_MAX",
+    "DEPLOY_CANDIDATE_RESERVE",
+    "GENCOW_APP_PORT_RANGE",
+    "COWBOX_WARM_POOL_PORT_RANGE",
+];
+export const PLATFORM_CAPACITY_PRESETS = Object.freeze({
+    prod: Object.freeze({
+        profile: "prod",
+        maxConcurrentRunning: 600,
+        maxConcurrentWake: 20,
+        maxWakeQueueMs: 5000,
+        minAvailableRamMB: 8192,
+        evictionThresholdMB: 16384,
+        sleepTimeoutMinutes: 15,
+        sleepMaxPerCycle: 50,
+        warmPoolMinIdle: 10,
+        warmPoolMax: 650,
+        deployCandidateReserve: 40,
+    }),
+    dev: Object.freeze({
+        profile: "dev",
+        maxConcurrentRunning: 60,
+        maxConcurrentWake: 5,
+        maxWakeQueueMs: 3000,
+        minAvailableRamMB: 2048,
+        evictionThresholdMB: 4096,
+        sleepTimeoutMinutes: 10,
+        sleepMaxPerCycle: 20,
+        warmPoolMinIdle: 3,
+        warmPoolMax: 70,
+        deployCandidateReserve: 5,
+    }),
+    local: Object.freeze({
+        profile: "local",
+        maxConcurrentRunning: null,
+        maxConcurrentWake: null,
+        maxWakeQueueMs: 5000,
+        minAvailableRamMB: null,
+        evictionThresholdMB: null,
+        sleepTimeoutMinutes: 30,
+        sleepMaxPerCycle: 10,
+        warmPoolMinIdle: 3,
+        warmPoolMax: 10,
+        deployCandidateReserve: 0,
+    }),
+});
+function normalizeDomain(value) {
+    return (value || "")
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/\/.*$/, "");
+}
+export function detectPlatformCapacityProfile(env = process.env) {
+    const explicit = env[PLATFORM_CAPACITY_PROFILE_ENV]?.trim().toLowerCase();
+    if (explicit) {
+        if (["prod", "production", "128gb"].includes(explicit))
+            return "prod";
+        if (["dev", "development", "16gb"].includes(explicit))
+            return "dev";
+        if (["local", "test", "disabled"].includes(explicit))
+            return "local";
+        throw new Error(`Invalid ${PLATFORM_CAPACITY_PROFILE_ENV}: ${explicit}. Expected prod, dev, or local.`);
+    }
+    const baseDomain = normalizeDomain(env.BASE_DOMAIN);
+    if (baseDomain === "gencow.dev")
+        return "dev";
+    if (baseDomain === "gencow.app")
+        return "prod";
+    const platformUrl = normalizeDomain(env.GENCOW_PLATFORM_URL);
+    if (platformUrl === "gencow.dev")
+        return "dev";
+    if (platformUrl === "gencow.app")
+        return "prod";
+    if (env.NODE_ENV === "production" && env.IS_PLATFORM === "true")
+        return "prod";
+    return "local";
+}
+export function resolvePlatformCapacityPreset(env = process.env) {
+    const profile = detectPlatformCapacityProfile(env);
+    return { ...PLATFORM_CAPACITY_PRESETS[profile] };
+}

package/dist/procedure.d.ts

@@ -0,0 +1,58 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { GencowCtx } from "./context.js";
+type InferInputSchema<TSchema> = TSchema extends {
+    "~standard": {
+        types: {
+            input: infer TInput;
+        };
+    };
+} ? TInput : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : unknown;
+type InferOutputSchema<TSchema> = TSchema extends {
+    "~standard": {
+        types: {
+            output: infer TOutput;
+        };
+    };
+} ? TOutput : TSchema extends {
+    _output: infer TOutput;
+} ? TOutput : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : unknown;
+type NextFn<TContext, TInput, TOutput> = (overrides?: {
+    context?: TContext;
+    input?: TInput;
+}) => Promise<TOutput>;
+export type GencowProcedureMiddleware<TContext, TInput, TOutput> = (options: {
+    context: TContext;
+    input: TInput;
+    next: NextFn<TContext, TInput, TOutput>;
+}) => Promise<TOutput> | TOutput;
+export type GencowProcedureHandler<TContext, TInput, TOutput> = (options: {
+    context: TContext;
+    input: TInput;
+}) => Promise<TOutput> | TOutput;
+export interface GencowProcedureDef<TKind extends "query" | "mutation" = "query" | "mutation", TContext = any, TInput = unknown, TOutput = unknown> {
+    kind: TKind;
+    name: string;
+    /** When false (default), RPC requires an authenticated user. */
+    isPublic: boolean;
+    middlewares: readonly GencowProcedureMiddleware<TContext, TInput, TOutput>[];
+    inputSchema?: StandardSchemaV1;
+    outputSchema?: StandardSchemaV1;
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: (context: TContext, input: TInput) => Promise<TOutput>;
+}
+export interface GencowProcedureBuilder<TKind extends "query" | "mutation" = "query" | "mutation", TContext = any, TInput = unknown, TOutput = unknown> {
+    name(name: string): GencowProcedureBuilder<TKind, TContext, TInput, TOutput>;
+    /**
+     * Allow calling this procedure without authentication (like `query("x", { public: true, ... })`).
+     * Default is authenticated-only.
+     */
+    allowPublic(): GencowProcedureBuilder<TKind, TContext, TInput, TOutput>;
+    use(middleware: GencowProcedureMiddleware<TContext, TInput, TOutput>): GencowProcedureBuilder<TKind, TContext, TInput, TOutput>;
+    input<TNextSchema extends StandardSchemaV1>(schema: TNextSchema): GencowProcedureBuilder<TKind, TContext, InferInputSchema<TNextSchema>, TOutput>;
+    output<TNextSchema extends StandardSchemaV1>(schema: TNextSchema): GencowProcedureBuilder<TKind, TContext, TInput, InferOutputSchema<TNextSchema>>;
+    handler(handler: GencowProcedureHandler<TContext, TInput, TOutput>): GencowProcedureDef<TKind, TContext, TInput, TOutput>;
+}
+export declare const procQuery: GencowProcedureBuilder<"query", GencowCtx>;
+export declare const procMutation: GencowProcedureBuilder<"mutation", GencowCtx>;
+export {};

package/dist/procedure.js

@@ -0,0 +1,115 @@
+function hasStandardSchema(schema) {
+    return (!!schema &&
+        typeof schema === "object" &&
+        "~standard" in schema &&
+        !!schema["~standard"] &&
+        typeof schema["~standard"].validate === "function");
+}
+async function validateWithSchema(schema, value) {
+    if (!schema)
+        return value;
+    if (hasStandardSchema(schema)) {
+        const result = (await schema["~standard"].validate(value));
+        if ("issues" in result && result.issues.length > 0) {
+            throw new Error(result.issues[0]?.message ?? "Validation failed");
+        }
+        if ("value" in result) {
+            return result.value;
+        }
+        throw new Error("Validation failed");
+    }
+    throw new Error("procQuery/procMutation only supports Standard Schema v1 validators");
+}
+function composeMiddlewares(middlewares, handler, inputSchema, outputSchema, inputValidationIndex, outputValidationIndex) {
+    return async (initialContext, initialInput) => {
+        let idx = -1;
+        const boundedInputValidationIndex = Math.min(Math.max(0, inputValidationIndex), middlewares.length);
+        const boundedOutputValidationIndex = Math.min(Math.max(0, outputValidationIndex), middlewares.length);
+        const run = async (currentIdx, context, input) => {
+            if (currentIdx <= idx) {
+                throw new Error("next() called multiple times in the same middleware");
+            }
+            idx = currentIdx;
+            let currentInput = input;
+            if (currentIdx === boundedInputValidationIndex) {
+                currentInput = (await validateWithSchema(inputSchema, currentInput));
+            }
+            if (currentIdx === middlewares.length) {
+                const output = await handler({ context, input: currentInput });
+                if (currentIdx === boundedOutputValidationIndex) {
+                    return await validateWithSchema(outputSchema, output);
+                }
+                return output;
+            }
+            const middleware = middlewares[currentIdx];
+            const output = await middleware({
+                context,
+                input: currentInput,
+                next: async (overrides) => {
+                    return await run(currentIdx + 1, (overrides?.context ?? context), (overrides?.input ?? currentInput));
+                },
+            });
+            if (currentIdx === boundedOutputValidationIndex) {
+                return await validateWithSchema(outputSchema, output);
+            }
+            return output;
+        };
+        return await run(0, initialContext, initialInput);
+    };
+}
+class GencowProcedureBuilderImpl {
+    kind;
+    procedureName;
+    middlewares;
+    inputSchema;
+    outputSchema;
+    inputValidationIndex;
+    outputValidationIndex;
+    isPublic;
+    constructor(kind, procedureName, middlewares = [], inputSchema, outputSchema, inputValidationIndex = -1, outputValidationIndex = -1, isPublic = false) {
+        this.kind = kind;
+        this.procedureName = procedureName;
+        this.middlewares = middlewares;
+        this.inputSchema = inputSchema;
+        this.outputSchema = outputSchema;
+        this.inputValidationIndex = inputValidationIndex;
+        this.outputValidationIndex = outputValidationIndex;
+        this.isPublic = isPublic;
+    }
+    name(name) {
+        return new GencowProcedureBuilderImpl(this.kind, name, this.middlewares, this.inputSchema, this.outputSchema, this.inputValidationIndex, this.outputValidationIndex, this.isPublic);
+    }
+    allowPublic() {
+        return new GencowProcedureBuilderImpl(this.kind, this.procedureName, this.middlewares, this.inputSchema, this.outputSchema, this.inputValidationIndex, this.outputValidationIndex, true);
+    }
+    use(middleware) {
+        return new GencowProcedureBuilderImpl(this.kind, this.procedureName, [...this.middlewares, middleware], this.inputSchema, this.outputSchema, this.inputValidationIndex, this.outputValidationIndex, this.isPublic);
+    }
+    input(schema) {
+        const nextInputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
+        return new GencowProcedureBuilderImpl(this.kind, this.procedureName, this.middlewares, schema, this.outputSchema, nextInputValidationIndex, this.outputValidationIndex, this.isPublic);
+    }
+    output(schema) {
+        const nextOutputValidationIndex = this.middlewares.length < 0 ? 0 : this.middlewares.length;
+        return new GencowProcedureBuilderImpl(this.kind, this.procedureName, this.middlewares, this.inputSchema, schema, this.inputValidationIndex, nextOutputValidationIndex, this.isPublic);
+    }
+    handler(handler) {
+        if (!this.procedureName) {
+            throw new Error("Procedure name is required. Call .name(...) before .handler(...)");
+        }
+        const run = composeMiddlewares(this.middlewares, handler, this.inputSchema, this.outputSchema, this.inputValidationIndex, this.outputValidationIndex);
+        return {
+            kind: this.kind,
+            name: this.procedureName,
+            isPublic: this.isPublic,
+            middlewares: [...this.middlewares],
+            inputSchema: this.inputSchema,
+            outputSchema: this.outputSchema,
+            inputValidationIndex: this.inputValidationIndex,
+            outputValidationIndex: this.outputValidationIndex,
+            handler: run,
+        };
+    }
+}
+export const procQuery = new GencowProcedureBuilderImpl("query");
+export const procMutation = new GencowProcedureBuilderImpl("mutation");

package/dist/rag-ingest-types.d.ts

@@ -0,0 +1,39 @@
+import type { DocumentConvertProvider, DocumentConvertMode, DocumentProviderTrace, DocumentVisibility } from "./document-types.js";
+export type RagIngestReindexMode = "if_changed" | "force";
+export type RagIngestJobStatus = "queued" | "converting" | "chunking" | "embedding" | "upserting" | "completed" | "failed" | "canceled";
+export type RagIngestInput = {
+    storageId: string;
+    corpus: string;
+    visibility: DocumentVisibility;
+    ownerUserId?: string;
+    sourceKey?: string;
+    metadata?: Record<string, unknown>;
+    reindexMode?: RagIngestReindexMode;
+    mode?: DocumentConvertMode;
+    provider?: DocumentConvertProvider;
+};
+export type RagIngestWorkflowArgs = RagIngestInput & {
+    jobId: string;
+    sourceId: string;
+};
+export type RagIngestStartResult = {
+    workflowId: string;
+    jobId: string;
+    sourceId: string;
+    status: "queued";
+};
+export type RagIngestJobRecord = {
+    id: string;
+    workflowId: string;
+    sourceId: string;
+    corpus: string;
+    visibility: DocumentVisibility;
+    ownerUserId: string | null;
+    status: RagIngestJobStatus;
+    stage: string;
+    providerTrace: Partial<DocumentProviderTrace> | Record<string, never>;
+    metrics: Record<string, unknown>;
+    error: string | null;
+    startedAt: string;
+    completedAt: string | null;
+};

package/dist/rag-ingest-types.js

@@ -0,0 +1 @@
+export {};

package/dist/rag-operations-types.d.ts

@@ -0,0 +1,81 @@
+import type { SearchScope } from "./search-types.js";
+export type RagOperationKind = "ingest" | "retrieve" | "answer" | "reindex" | "evaluate";
+export type RagOperationMetricUnit = "ms" | "count" | "tokens" | "usd";
+export type RagIndexHealth = "ready" | "empty" | "degraded" | "failed";
+export type RagOperationMetric = {
+    id: string;
+    appId: string;
+    corpus: string;
+    visibility: SearchScope["visibility"];
+    ownerUserId: string | null;
+    operation: RagOperationKind;
+    jobId: string | null;
+    workflowId: string | null;
+    sourceId: string | null;
+    metricName: string;
+    metricValue: number;
+    unit: RagOperationMetricUnit | null;
+    metadata: Record<string, unknown>;
+    recordedAt: string;
+};
+export type RagOperationsSummary = {
+    corpus: string;
+    visibility: SearchScope["visibility"];
+    ownerUserId: string | null;
+    sourceCount: number;
+    sectionCount: number;
+    chunkCount: number;
+    jobCounts: Record<string, number>;
+    latestJob: {
+        id: string;
+        status: string;
+        stage: string;
+        updatedAt: string;
+    } | null;
+    recentMetricCounts: Record<string, number>;
+    averageLatencyMs: number | null;
+    indexHealth: RagIndexHealth;
+};
+export type RagEvaluationExpectedClaim = {
+    claim: string;
+    verdict: "supported" | "partial" | "unsupported";
+};
+export type RagEvaluationFixture = {
+    name: string;
+    scope: SearchScope;
+    query: string;
+    expectedSourceIds?: string[];
+    expectedCitationCountMin?: number;
+    expectedClaims?: RagEvaluationExpectedClaim[];
+};
+export type RagEvaluationFixtureResult = {
+    name: string;
+    ok: boolean;
+    failures: string[];
+    matchedSourceIds: string[];
+    citationCount: number;
+    claimStatuses: Array<{
+        claim: string;
+        expected: RagEvaluationExpectedClaim["verdict"];
+        actual: string | null;
+    }>;
+};
+export type RagEvaluationRunResult = {
+    ok: boolean;
+    total: number;
+    passed: number;
+    failed: number;
+    results: RagEvaluationFixtureResult[];
+};
+export type RagReindexMode = "source-changed" | "section-changed" | "corpus-policy-changed" | "full-rebuild";
+export type RagReindexPlan = {
+    corpus: string;
+    visibility: SearchScope["visibility"];
+    ownerUserId: string | null;
+    mode: RagReindexMode;
+    reason: string;
+    sourceIds: string[];
+    sourceCount: number;
+    estimatedChunkCount: number;
+    requiresConfirmation: boolean;
+};

package/dist/rag-operations-types.js

@@ -0,0 +1 @@
+export {};