@vouched-dev/schema 0.1.0

package/dist/db/task-outcomes.d.ts

@@ -0,0 +1,126 @@
+export declare const taskOutcomes: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "task_outcomes";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "task_outcomes";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "task_outcomes";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "task_outcomes";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        taskId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "task_id";
+            tableName: "task_outcomes";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        reportingAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "reporting_agent_id";
+            tableName: "task_outcomes";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        outcome: import("drizzle-orm/pg-core").PgColumn<{
+            name: "outcome";
+            tableName: "task_outcomes";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        evidence: import("drizzle-orm/pg-core").PgColumn<{
+            name: "evidence";
+            tableName: "task_outcomes";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/task-outcomes.js

@@ -0,0 +1,18 @@
+import { jsonb, pgTable, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+import { tasks } from './tasks.js';
+import { timestamps } from './timestamps.js';
+export const taskOutcomes = pgTable('task_outcomes', {
+    id: uuid('id').primaryKey(),
+    taskId: uuid('task_id')
+        .notNull()
+        .references(() => tasks.id),
+    reportingAgentId: text('reporting_agent_id')
+        .notNull()
+        .references(() => agents.id),
+    outcome: text('outcome').notNull(),
+    evidence: jsonb('evidence'),
+    ...timestamps,
+}, (t) => [
+    unique('task_outcomes_task_id_reporting_agent_id_unique').on(t.taskId, t.reportingAgentId),
+]);

package/dist/db/tasks.d.ts

@@ -0,0 +1,251 @@
+export declare const tasks: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "tasks";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        posterAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "poster_agent_id";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        claimantAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "claimant_agent_id";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        taskType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "task_type";
+            tableName: "tasks";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        spec: import("drizzle-orm/pg-core").PgColumn<{
+            name: "spec";
+            tableName: "tasks";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        verification: import("drizzle-orm/pg-core").PgColumn<{
+            name: "verification";
+            tableName: "tasks";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        postedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "posted_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        claimedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "claimed_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        submittedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "submitted_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "verified_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        submission: import("drizzle-orm/pg-core").PgColumn<{
+            name: "submission";
+            tableName: "tasks";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                text: string;
+            };
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                text: string;
+            };
+        }>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "tasks";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/db/tasks.js

@@ -0,0 +1,26 @@
+import { jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { agents } from './agents.js';
+import { timestamps } from './timestamps.js';
+export const tasks = pgTable('tasks', {
+    id: uuid('id').primaryKey(),
+    posterAgentId: text('poster_agent_id')
+        .notNull()
+        .references(() => agents.id),
+    claimantAgentId: text('claimant_agent_id').references(() => agents.id),
+    taskType: text('task_type').notNull(),
+    spec: jsonb('spec').notNull(),
+    verification: jsonb('verification').notNull(),
+    postedAt: timestamp('posted_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    claimedAt: timestamp('claimed_at', { withTimezone: true }),
+    submittedAt: timestamp('submitted_at', { withTimezone: true }),
+    verifiedAt: timestamp('verified_at', { withTimezone: true }),
+    // What the claimant submitted, null until submit. Only the poster and the
+    // claimant may read it. Wrapped in an object because a bare jsonb string
+    // does not survive a read. postgres-js parses jsonb and Drizzle then
+    // JSON.parses any string it gets back, so "123" would return as 123.
+    submission: jsonb('submission').$type(),
+    expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+    ...timestamps,
+});

package/dist/db/timestamps.d.ts

@@ -0,0 +1,4 @@
+export declare const timestamps: {
+    createdAt: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/pg-core").PgTimestampBuilderInitial<"created_at">>>;
+    updatedAt: import("drizzle-orm").HasDefault<import("drizzle-orm").NotNull<import("drizzle-orm/pg-core").PgTimestampBuilderInitial<"updated_at">>>;
+};

package/dist/db/timestamps.js

@@ -0,0 +1,24 @@
+import { timestamp } from 'drizzle-orm/pg-core';
+// Shared columns for every table except events.
+//
+// A column builder like timestamp('created_at', ...) describes a column but
+// is not bound to a table yet. pgTable binds it when the table is declared,
+// so one plain object of builders can be spread into many tables.
+//
+//   export const agents = pgTable('agents', {
+//     id: text('id').primaryKey(),
+//     ...timestamps,
+//   });
+//
+// Both columns are set by the database. defaultNow() fills them on insert and
+// the set_updated_at() trigger in the second migration bumps updated_at on
+// every update. We do not use Drizzle's $onUpdate, because that only runs
+// when the update goes through Drizzle.
+export const timestamps = {
+    createdAt: timestamp('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+};

package/dist/db/url.d.ts

@@ -0,0 +1,12 @@
+import type { Options } from 'postgres';
+/**
+ * Turns DATABASE_URL into arguments for postgres.js.
+ *
+ * On Cloud Run the URL uses the Cloud SQL socket form with an empty host,
+ * `postgres://user:pass@/db?host=/cloudsql/project:region:instance`.
+ * postgres.js cannot parse an empty host and ignores `?host=`, so this moves
+ * the socket directory into the `path` option. Other URLs pass through.
+ *
+ * Errors never include the URL, because it carries the password.
+ */
+export declare function pgArgs(databaseUrl: string): [string, Options<never>];

package/dist/db/url.js

@@ -0,0 +1,25 @@
+/**
+ * Turns DATABASE_URL into arguments for postgres.js.
+ *
+ * On Cloud Run the URL uses the Cloud SQL socket form with an empty host,
+ * `postgres://user:pass@/db?host=/cloudsql/project:region:instance`.
+ * postgres.js cannot parse an empty host and ignores `?host=`, so this moves
+ * the socket directory into the `path` option. Other URLs pass through.
+ *
+ * Errors never include the URL, because it carries the password.
+ */
+export function pgArgs(databaseUrl) {
+    const withHost = databaseUrl.replace(/^(postgres(?:ql)?:\/\/[^/@]*@)\//, '$1localhost/');
+    let u;
+    try {
+        u = new URL(withHost);
+    }
+    catch {
+        throw new Error('DATABASE_URL is not a valid postgres URL');
+    }
+    const socketDir = u.searchParams.get('host');
+    if (!socketDir)
+        return [databaseUrl, {}];
+    u.searchParams.delete('host');
+    return [u.toString(), { path: `${socketDir}/.s.PGSQL.${u.port || 5432}` }];
+}

package/dist/dimensions.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const TaskType: z.ZodString;
+export type TaskType = z.infer<typeof TaskType>;
+export declare const BaseDimension: z.ZodEnum<{
+    cost_latency: "cost_latency";
+    provenance: "provenance";
+    reliability: "reliability";
+    safety: "safety";
+}>;
+export type BaseDimension = z.infer<typeof BaseDimension>;
+export declare const CompetenceDimension: z.ZodTemplateLiteral<`competence:${string}`>;
+export type CompetenceDimension = z.infer<typeof CompetenceDimension>;
+export declare const Dimension: z.ZodUnion<readonly [z.ZodEnum<{
+    cost_latency: "cost_latency";
+    provenance: "provenance";
+    reliability: "reliability";
+    safety: "safety";
+}>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+export type Dimension = z.infer<typeof Dimension>;
+export declare const competence: (taskType: TaskType) => CompetenceDimension;

package/dist/dimensions.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export const TaskType = z.string().regex(/^[a-z0-9_-]{1,32}$/);
+export const BaseDimension = z.enum([
+    'reliability',
+    'safety',
+    'cost_latency',
+    'provenance',
+]);
+export const CompetenceDimension = z.templateLiteral(['competence:', TaskType]);
+export const Dimension = z.union([BaseDimension, CompetenceDimension]);
+export const competence = (taskType) => CompetenceDimension.parse(`competence:${taskType}`);

package/dist/envelope.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const Jws: z.ZodString;
+export declare const JwsHeader: z.ZodObject<{
+    alg: z.ZodLiteral<"EdDSA">;
+    kid: z.ZodString;
+}, z.core.$strict>;
+export type JwsHeader = z.infer<typeof JwsHeader>;
+export declare class EnvelopeError extends Error {
+    name: string;
+}
+export declare function sign(payload: unknown, privateKey: Uint8Array, kid: string): Promise<string>;
+export declare function decodeHeader(jws: string): JwsHeader;
+export declare function verify(jws: string, publicKey: Uint8Array): Promise<{
+    header: JwsHeader;
+    payload: unknown;
+}>;

package/dist/envelope.js

@@ -0,0 +1,70 @@
+import { signAsync, verifyAsync } from '@noble/ed25519';
+import { z } from 'zod';
+import { base64urlDecode, base64urlEncode, utf8Decode, utf8Encode, } from './base64url.js';
+// The outer cap matches the API body limit. Routes set a tighter one.
+export const Jws = z
+    .string()
+    .max(262144)
+    .regex(/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/, 'Expected JWS compact');
+export const JwsHeader = z.strictObject({
+    alg: z.literal('EdDSA'),
+    kid: z.string().min(1).max(128),
+});
+export class EnvelopeError extends Error {
+    name = 'EnvelopeError';
+}
+function split(jws) {
+    if (!Jws.safeParse(jws).success) {
+        throw new EnvelopeError('Envelope is not three base64url parts');
+    }
+    const [header, payload, signature] = jws.split('.');
+    return { header, payload, signature };
+}
+function parseJson(part, what) {
+    try {
+        return JSON.parse(utf8Decode(base64urlDecode(part)));
+    }
+    catch {
+        throw new EnvelopeError(`Envelope ${what} is not base64url JSON`);
+    }
+}
+function parseHeader(part) {
+    const result = JwsHeader.safeParse(parseJson(part, 'header'));
+    if (!result.success) {
+        throw new EnvelopeError('Envelope header must be alg EdDSA with a kid');
+    }
+    return result.data;
+}
+export async function sign(payload, privateKey, kid) {
+    const header = JwsHeader.parse({ alg: 'EdDSA', kid });
+    const body = JSON.stringify(payload);
+    if (body === undefined)
+        throw new EnvelopeError('Payload is not JSON');
+    const signingInput = `${base64urlEncode(utf8Encode(JSON.stringify(header)))}.${base64urlEncode(utf8Encode(body))}`;
+    const signature = await signAsync(utf8Encode(signingInput), privateKey);
+    return `${signingInput}.${base64urlEncode(signature)}`;
+}
+export function decodeHeader(jws) {
+    return parseHeader(split(jws).header);
+}
+export async function verify(jws, publicKey) {
+    const parts = split(jws);
+    const signingInput = utf8Encode(`${parts.header}.${parts.payload}`);
+    let ok = false;
+    try {
+        const signature = base64urlDecode(parts.signature);
+        ok =
+            signature.length === 64 &&
+                publicKey.length === 32 &&
+                (await verifyAsync(signature, signingInput, publicKey, {
+                    zip215: false,
+                }));
+    }
+    catch {
+        ok = false;
+    }
+    if (!ok)
+        throw new EnvelopeError('Envelope signature is invalid');
+    const header = parseHeader(parts.header);
+    return { header, payload: parseJson(parts.payload, 'payload') };
+}