@undefineds.co/models 0.2.34 → 0.2.37

package/dist/namespaces.js

@@ -43,6 +43,7 @@ export const SCHEMA = createNamespace('schema', 'http://schema.org/', {
     CreativeWork: 'CreativeWork',
     MediaObject: 'MediaObject',
     PropertyValue: 'PropertyValue',
+    about: 'about',
     author: 'author',
     dateCreated: 'dateCreated',
     dateDeleted: 'dateDeleted',
@@ -52,6 +53,7 @@ export const SCHEMA = createNamespace('schema', 'http://schema.org/', {
     image: 'image',
     name: 'name',
     participant: 'participant',
+    reviewedBy: 'reviewedBy',
     text: 'text',
     url: 'url',
 });
@@ -87,6 +89,7 @@ export const AS = createNamespace('as', 'https://www.w3.org/ns/activitystreams#'
     audience: 'audience',
     actor: 'actor',
     object: 'object',
+    target: 'target',
 });
 // Company-level namespace (community-first guidance): all custom terms live under udfs:.
 // NOTE: This base URI is part of the contract.
@@ -95,10 +98,27 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     ApprovalRequest: 'ApprovalRequest',
     AuditEntry: 'AuditEntry',
     AutonomyGrant: 'AutonomyGrant',
+    Idea: 'Idea',
     Issue: 'Issue',
     Task: 'Task',
+    Schedule: 'Schedule',
+    AutomationRule: 'AutomationRule',
+    Delivery: 'Delivery',
     Run: 'Run',
     RunStep: 'RunStep',
+    Evidence: 'Evidence',
+    Report: 'Report',
+    Credential: 'Credential',
+    ApiKeyCredential: 'ApiKeyCredential',
+    OAuthCredential: 'OAuthCredential',
+    Provider: 'Provider',
+    Model: 'Model',
+    AIConfig: 'AIConfig',
+    VectorStore: 'VectorStore',
+    IndexedFile: 'IndexedFile',
+    AgentStatus: 'AgentStatus',
+    Skill: 'Skill',
+    name: 'name',
     favorite: 'favorite',
     favoriteType: 'favoriteType',
     favoriteTarget: 'favoriteTarget',
@@ -112,13 +132,12 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     sortKey: 'sortKey',
     hasThread: 'hasThread',
     inThread: 'inThread',
+    inScope: 'inScope',
     participants: 'participants',
+    message: 'message',
     messageContent: 'messageContent',
-    messageResource: 'messageResource',
     messageType: 'messageType',
     messageStatus: 'messageStatus',
-    commandKind: 'commandKind',
-    surfaceId: 'surfaceId',
     readBy: 'readBy',
     Contact: 'Contact',
     PersonContact: 'PersonContact',
@@ -126,7 +145,6 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     GroupContact: 'GroupContact',
     hasContact: 'hasContact',
     contactType: 'contactType',
-    entityUri: 'entityUri',
     externalPlatform: 'externalPlatform',
     externalId: 'externalId',
     alias: 'alias',
@@ -141,7 +159,32 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     systemMessage: 'systemMessage',
     provider: 'provider',
     model: 'model',
+    displayName: 'displayName',
+    proxyUrl: 'proxyUrl',
+    hasModel: 'hasModel',
+    defaultModel: 'defaultModel',
+    modelType: 'modelType',
+    isProvidedBy: 'isProvidedBy',
+    dimension: 'dimension',
+    supportsBackend: 'supportsBackend',
+    rotationPolicy: 'rotationPolicy',
     metadata: 'metadata',
+    root: 'root',
+    webId: 'webId',
+    hasSkill: 'hasSkill',
+    skill: 'skill',
+    enabled: 'enabled',
+    version: 'version',
+    checksum: 'checksum',
+    loadPolicy: 'loadPolicy',
+    credentialSource: 'credentialSource',
+    backend: 'backend',
+    runtime: 'runtime',
+    transport: 'transport',
+    endpoint: 'endpoint',
+    authorityPolicy: 'authorityPolicy',
+    toolPolicy: 'toolPolicy',
+    runtimeSnapshot: 'runtimeSnapshot',
     tools: 'tools',
     contextWindow: 'contextWindow',
     contextRound: 'contextRound',
@@ -153,6 +196,17 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     syncStatus: 'syncStatus',
     localPath: 'localPath',
     isDefault: 'isDefault',
+    service: 'service',
+    label: 'label',
+    lastUsedAt: 'lastUsedAt',
+    failCount: 'failCount',
+    rateLimitResetAt: 'rateLimitResetAt',
+    oauthRefreshToken: 'oauthRefreshToken',
+    oauthAccessToken: 'oauthAccessToken',
+    oauthExpiresAt: 'oauthExpiresAt',
+    projectId: 'projectId',
+    organizationId: 'organizationId',
+    secretType: 'secretType',
     settingKey: 'settingKey',
     settingValue: 'settingValue',
     settingType: 'settingType',
@@ -161,13 +215,34 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     inbox: 'inbox',
     issue: 'issue',
     task: 'task',
-    triggerKind: 'triggerKind',
-    cron: 'cron',
-    intervalSeconds: 'intervalSeconds',
-    eventName: 'eventName',
-    nextRunAt: 'nextRunAt',
-    lastRunAt: 'lastRunAt',
+    schedule: 'schedule',
+    automationRule: 'automationRule',
+    delivery: 'delivery',
+    deliveryKind: 'deliveryKind',
+    scheduleKind: 'scheduleKind',
+    ruleKind: 'ruleKind',
+    instruction: 'instruction',
+    input: 'input',
+    trigger: 'trigger',
+    condition: 'condition',
+    actions: 'actions',
+    objective: 'objective',
+    payload: 'payload',
+    projection: 'projection',
+    target: 'target',
+    targetThread: 'targetThread',
+    targetSession: 'targetSession',
+    projectedRole: 'projectedRole',
+    consumedAt: 'consumedAt',
     priority: 'priority',
+    commitment: 'commitment',
+    affectedArea: 'affectedArea',
+    currentUnderstanding: 'currentUnderstanding',
+    openQuestions: 'openQuestions',
+    conflicts: 'conflicts',
+    nextStep: 'nextStep',
+    promotedTo: 'promotedTo',
+    sourceMessage: 'sourceMessage',
     parentIssue: 'parentIssue',
     session: 'session',
     status: 'status',
@@ -187,6 +262,7 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     body: 'body',
     tags: 'tags',
     source: 'source',
+    sourceKind: 'sourceKind',
     sourceHash: 'sourceHash',
     compiledAt: 'compiledAt',
     compiledFrom: 'compiledFrom',
@@ -208,10 +284,10 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     videoModel: 'videoModel',
     chatType: 'chatType',
     workspace: 'workspace',
-    container: 'workspace',
+    container: 'container',
     policyRef: 'policyRef',
     policyVersion: 'policyVersion',
-    parentThreadId: 'parentThreadId',
+    parentThread: 'parentThread',
     sessionStatus: 'sessionStatus',
     runner: 'runner',
     prompt: 'prompt',
@@ -221,12 +297,42 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     heartbeatAt: 'heartbeatAt',
     cancelRequestedAt: 'cancelRequestedAt',
     startedAt: 'startedAt',
+    startsAt: 'startsAt',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt',
     completedAt: 'completedAt',
+    nextRunAt: 'nextRunAt',
+    lastRunAt: 'lastRunAt',
+    lastTriggeredAt: 'lastTriggeredAt',
+    lastRunStatus: 'lastRunStatus',
+    cron: 'cron',
+    intervalSeconds: 'intervalSeconds',
+    timezone: 'timezone',
     error: 'error',
-    runId: 'runId',
     run: 'run',
+    stepType: 'stepType',
+    evidence: 'evidence',
+    evidenceKind: 'evidenceKind',
+    report: 'report',
+    reportKind: 'reportKind',
+    outcome: 'outcome',
+    metricFacts: 'metricFacts',
+    publishedAt: 'publishedAt',
+    reviewer: 'reviewer',
     sessionTool: 'sessionTool',
     tokenUsage: 'tokenUsage',
+    embeddingModel: 'embeddingModel',
+    previousModel: 'previousModel',
+    migrationStatus: 'migrationStatus',
+    migrationProgress: 'migrationProgress',
+    chunkingStrategy: 'chunkingStrategy',
+    fileUrl: 'fileUrl',
+    vectorId: 'vectorId',
+    usageBytes: 'usageBytes',
+    lastError: 'lastError',
+    indexedAt: 'indexedAt',
+    lastActivityAt: 'lastActivityAt',
+    errorMessage: 'errorMessage',
     groupOwner: 'groupOwner',
     groupAdmin: 'groupAdmin',
     senderName: 'senderName',
@@ -234,8 +340,9 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     mentions: 'mentions',
     replyTo: 'replyTo',
     routedBy: 'routedBy',
-    routeTargetAgentId: 'routeTargetAgentId',
+    routeTargetAgent: 'routeTargetAgent',
     coordinationId: 'coordinationId',
+    agent: 'agent',
     toolCallId: 'toolCallId',
     toolName: 'toolName',
     toolArguments: 'toolArguments',
@@ -254,87 +361,9 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     taskSteps: 'taskSteps',
     currentStep: 'currentStep',
     totalSteps: 'totalSteps',
-    // Matrix protocol adapter
-    MatrixAccount: 'MatrixAccount',
-    MatrixRoom: 'MatrixRoom',
-    MatrixEvent: 'MatrixEvent',
-    matrixUserId: 'matrixUserId',
-    matrixDeviceId: 'matrixDeviceId',
-    matrixAccessTokenHash: 'matrixAccessTokenHash',
-    matrixRoomId: 'matrixRoomId',
-    matrixRoomAlias: 'matrixRoomAlias',
-    matrixRoomVersion: 'matrixRoomVersion',
-    matrixEventId: 'matrixEventId',
-    matrixEventType: 'matrixEventType',
-    matrixStateKey: 'matrixStateKey',
-    matrixSender: 'matrixSender',
-    matrixSenderWebId: 'matrixSenderWebId',
-    matrixTxnId: 'matrixTxnId',
-    matrixDepth: 'matrixDepth',
-    matrixOriginServerTs: 'matrixOriginServerTs',
-    matrixUnsigned: 'matrixUnsigned',
     // Favorites V2
     sourceModule: 'sourceModule',
-    sourceId: 'sourceId',
     searchText: 'searchText',
     snapshotMeta: 'snapshotMeta',
 });
 export const UDFS_NAMESPACE = UDFS.NAMESPACE;
-export const XPOD_CREDENTIAL = createNamespace('cred', 'https://vocab.xpod.dev/credential#', {
-    Credential: 'Credential',
-    ApiKeyCredential: 'ApiKeyCredential',
-    OAuthCredential: 'OAuthCredential',
-    provider: 'provider',
-    service: 'service',
-    status: 'status',
-    apiKey: 'apiKey',
-    baseUrl: 'baseUrl',
-    proxyUrl: 'proxyUrl',
-    label: 'label',
-    isDefault: 'isDefault',
-    lastUsedAt: 'lastUsedAt',
-    failCount: 'failCount',
-    rateLimitResetAt: 'rateLimitResetAt',
-    oauthRefreshToken: 'oauthRefreshToken',
-    oauthAccessToken: 'oauthAccessToken',
-    oauthExpiresAt: 'oauthExpiresAt',
-    projectId: 'projectId',
-    organizationId: 'organizationId',
-});
-export const XPOD_AI = createNamespace('ai', 'https://vocab.xpod.dev/ai#', {
-    Provider: 'Provider',
-    Model: 'Model',
-    AIConfig: 'AIConfig',
-    VectorStore: 'VectorStore',
-    IndexedFile: 'IndexedFile',
-    AgentStatus: 'AgentStatus',
-    baseUrl: 'baseUrl',
-    proxyUrl: 'proxyUrl',
-    hasModel: 'hasModel',
-    defaultModel: 'defaultModel',
-    displayName: 'displayName',
-    modelType: 'modelType',
-    isProvidedBy: 'isProvidedBy',
-    dimension: 'dimension',
-    status: 'status',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt',
-    embeddingModel: 'embeddingModel',
-    previousModel: 'previousModel',
-    migrationStatus: 'migrationStatus',
-    migrationProgress: 'migrationProgress',
-    name: 'name',
-    container: 'container',
-    chunkingStrategy: 'chunkingStrategy',
-    lastActiveAt: 'lastActiveAt',
-    lastActivityAt: 'lastActivityAt',
-    fileUrl: 'fileUrl',
-    vectorId: 'vectorId',
-    usageBytes: 'usageBytes',
-    lastError: 'lastError',
-    indexedAt: 'indexedAt',
-    agentId: 'agentId',
-    startedAt: 'startedAt',
-    currentTaskId: 'currentTaskId',
-    errorMessage: 'errorMessage',
-});

package/dist/pod-storage-descriptor.d.ts

@@ -22,12 +22,6 @@ export interface PodModelDescriptor {
     storage: {
         base: string;
         resourceIdPattern: string;
-        /**
-         * @deprecated subjectTemplate exists only for legacy fragment layouts.
-         * New descriptors should express exact base-relative ids through
-         * resourceIdPattern and store those ids directly.
-         */
-        subjectTemplate?: string;
     };
     fields: Record<string, PodModelFieldDescriptor>;
     uniqueBy: string[];

package/dist/pod-storage-descriptor.js

@@ -1,57 +1,56 @@
-import { XPOD_CREDENTIAL } from './namespaces.js';
+import { UDFS } from './namespaces.js';
 export const credentialDescriptor = {
-    uri: XPOD_CREDENTIAL.Credential,
+    uri: UDFS.Credential,
     version: '1.0.0',
     source: 'official',
     trustLevel: 'high',
-    namespace: XPOD_CREDENTIAL.NAMESPACE,
-    class: XPOD_CREDENTIAL.Credential,
+    namespace: UDFS.NAMESPACE,
+    class: UDFS.Credential,
     resourceKind: 'credential',
     description: 'Generic credential material required by runtimes, tools, MCP servers, and providers.',
     storage: {
         base: '/settings/credentials.ttl',
         resourceIdPattern: '#{id}',
-        subjectTemplate: '#{id}',
     },
     fields: {
         id: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.term('id'),
+            predicate: UDFS.term('id'),
             required: true,
             description: 'Local credential id.',
         },
         service: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.service,
+            predicate: UDFS.service,
             required: true,
             description: 'Credential service grouping, for example ai or infra.',
         },
         providerId: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.provider,
+            predicate: UDFS.provider,
             required: true,
             description: 'Provider identifier such as openai or cloudflare.',
         },
         secretType: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.term('secretType'),
+            predicate: UDFS.secretType,
             required: true,
             description: 'Provider-specific secret kind such as api-key or tunnel-token.',
         },
         label: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.label,
+            predicate: UDFS.label,
             description: 'User-facing credential label.',
         },
         apiKey: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.apiKey,
+            predicate: UDFS.apiKey,
             secret: true,
             description: 'Secret token or API key material.',
         },
         status: {
             type: 'string',
-            predicate: XPOD_CREDENTIAL.status,
+            predicate: UDFS.status,
             description: 'Credential health status.',
         },
     },

package/dist/profile.repository.d.ts

@@ -1,4 +1,4 @@
-import { type AnyPodTable } from './repository.js';
+import { type AnyPodResource } from './repository.js';
 import { type SolidProfileRow } from './profile.schema.js';
 export interface SolidProfileIdentity {
     webId: string;
@@ -7,7 +7,7 @@ export interface SolidProfileIdentity {
     username: string;
 }
 export interface SolidProfileRepositoryReader {
-    findByIri?(table: AnyPodTable, iri: string): Promise<unknown | null>;
+    findByIri(resource: AnyPodResource, iri: string): Promise<unknown>;
 }
 export declare const profileRepository: {
     findByWebId(db: SolidProfileRepositoryReader, webId: string): Promise<SolidProfileRow | null>;

package/dist/profile.repository.js

@@ -3,7 +3,7 @@ import { definePodRepository } from './repository.js';
 import { solidProfileResource, } from './profile.schema.js';
 const baseProfileRepository = definePodRepository({
     namespace: 'profile',
-    table: solidProfileResource,
+    resource: solidProfileResource,
     searchableFields: ['name', 'nick'],
     disableMutations: {
         create: true,
@@ -17,7 +17,7 @@ export const profileRepository = {
         if (!webId.trim()) {
             return null;
         }
-        return await db.findByIri?.(solidProfileResource, webId) ?? null;
+        return await db.findByIri(solidProfileResource, webId);
     },
     async resolveDisplayName(db, webId) {
         return pickSolidProfileDisplayName(await profileRepository.findByWebId(db, webId));

package/dist/report.schema.d.ts

@@ -0,0 +1,58 @@
+export type ReportKindType = 'closure' | 'review' | 'status' | 'handoff' | 'quality';
+export type ReportStatusType = 'draft' | 'published' | 'accepted' | 'rejected' | 'superseded';
+export type ReportOutcomeType = 'accepted' | 'rejected' | 'reopened' | 'partial_release' | 'deferred' | 'blocked' | 'change_requested';
+export declare const ReportKind: {
+    readonly CLOSURE: "closure";
+    readonly REVIEW: "review";
+    readonly STATUS: "status";
+    readonly HANDOFF: "handoff";
+    readonly QUALITY: "quality";
+};
+export declare const ReportStatus: {
+    readonly DRAFT: "draft";
+    readonly PUBLISHED: "published";
+    readonly ACCEPTED: "accepted";
+    readonly REJECTED: "rejected";
+    readonly SUPERSEDED: "superseded";
+};
+export declare const ReportOutcome: {
+    readonly ACCEPTED: "accepted";
+    readonly REJECTED: "rejected";
+    readonly REOPENED: "reopened";
+    readonly PARTIAL_RELEASE: "partial_release";
+    readonly DEFERRED: "deferred";
+    readonly BLOCKED: "blocked";
+    readonly CHANGE_REQUESTED: "change_requested";
+};
+/**
+ * Report resource.
+ *
+ * Report is the authoritative closure, review, handoff, status, or quality
+ * summary resource. The resource subject is the report file/record itself;
+ * `about` points to the control object being summarized.
+ */
+export declare const reportResource: import("@undefineds.co/drizzle-solid/dist/core/schema").PodTableWithColumns<import("@undefineds.co/drizzle-solid/dist/core/schema").ResolvedColumns<{
+    id: import("@undefineds.co/drizzle-solid/dist/core/schema").PodStringColumn<false, false>;
+    reportKind: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    status: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, true>;
+    outcome: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, false, false>;
+    about: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, true, false>;
+    issue: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    task: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    delivery: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    run: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    thread: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    evidence: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"array", "uri", false, false>;
+    summary: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"string", null, true, false>;
+    reviewer: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    actor: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    source: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"uri", null, false, false>;
+    metricFacts: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    metadata: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"object", null, false, false>;
+    createdAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+    publishedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, false, false>;
+    updatedAt: import("@undefineds.co/drizzle-solid/dist/core/schema").ColumnBuilder<"datetime", null, true, true>;
+}>>;
+export type ReportRow = typeof reportResource.$inferSelect;
+export type ReportInsert = typeof reportResource.$inferInsert;
+export type ReportUpdate = typeof reportResource.$inferUpdate;

package/dist/report.schema.js

@@ -0,0 +1,73 @@
+import { id, object, podTable, renderDefaultIdTemplate, string, text, timestamp, uri } from '@undefineds.co/drizzle-solid';
+import { DCTerms, SCHEMA, UDFS } from './namespaces.js';
+import { deliveryResource } from './delivery.schema.js';
+import { evidenceResource } from './evidence.schema.js';
+import { issueResource } from './issue.schema.js';
+import { runResource } from './run.schema.js';
+import { taskResource } from './task.schema.js';
+import { threadResource } from './thread.schema.js';
+import { resourceKey, workflowOwnerDir } from './resource-id-defaults.js';
+export const ReportKind = {
+    CLOSURE: 'closure',
+    REVIEW: 'review',
+    STATUS: 'status',
+    HANDOFF: 'handoff',
+    QUALITY: 'quality',
+};
+export const ReportStatus = {
+    DRAFT: 'draft',
+    PUBLISHED: 'published',
+    ACCEPTED: 'accepted',
+    REJECTED: 'rejected',
+    SUPERSEDED: 'superseded',
+};
+export const ReportOutcome = {
+    ACCEPTED: 'accepted',
+    REJECTED: 'rejected',
+    REOPENED: 'reopened',
+    PARTIAL_RELEASE: 'partial_release',
+    DEFERRED: 'deferred',
+    BLOCKED: 'blocked',
+    CHANGE_REQUESTED: 'change_requested',
+};
+/**
+ * Report resource.
+ *
+ * Report is the authoritative closure, review, handoff, status, or quality
+ * summary resource. The resource subject is the report file/record itself;
+ * `about` points to the control object being summarized.
+ */
+export const reportResource = podTable('report', {
+    id: id('id').default((key, row) => {
+        const localKey = resourceKey(key, 'report');
+        const ownerDir = workflowOwnerDir(row) ?? 'reports';
+        return renderDefaultIdTemplate(`${ownerDir}/{yyyy}/{MM}/{dd}/reports.ttl#{key}`, {
+            key: localKey,
+            row,
+        });
+    }),
+    reportKind: string('reportKind').predicate(UDFS.reportKind).notNull(),
+    status: string('status').predicate(UDFS.status).notNull().default(ReportStatus.DRAFT),
+    outcome: string('outcome').predicate(UDFS.outcome),
+    about: uri('about').predicate(SCHEMA.about).notNull(),
+    issue: uri('issue').predicate(UDFS.issue).link(issueResource),
+    task: uri('task').predicate(UDFS.task).link(taskResource),
+    delivery: uri('delivery').predicate(UDFS.delivery).link(deliveryResource),
+    run: uri('run').predicate(UDFS.run).link(runResource),
+    thread: uri('thread').predicate(UDFS.inThread).link(threadResource),
+    evidence: uri('evidence').predicate(UDFS.evidence).array().link(evidenceResource),
+    summary: text('summary').predicate(DCTerms.abstract).notNull(),
+    reviewer: uri('reviewer').predicate(SCHEMA.reviewedBy),
+    actor: uri('actor').predicate(DCTerms.creator),
+    source: uri('source').predicate(DCTerms.source),
+    metricFacts: object('metricFacts').predicate(UDFS.metricFacts),
+    metadata: object('metadata').predicate(UDFS.metadata),
+    createdAt: timestamp('createdAt').predicate(DCTerms.created).notNull().defaultNow(),
+    publishedAt: timestamp('publishedAt').predicate(DCTerms.issued),
+    updatedAt: timestamp('updatedAt').predicate(DCTerms.modified).notNull().defaultNow(),
+}, {
+    base: '/.data/',
+    sparqlEndpoint: '/.data/-/sparql',
+    type: UDFS.Report,
+    namespace: UDFS,
+});

package/dist/repository.d.ts

@@ -1,8 +1,19 @@
-import { initSolidTables, type AnyPodTable } from '@undefineds.co/drizzle-solid';
-export { createRepositoryDescriptor, definePodRepository, type PodRepositoryDescriptor, type RepositoryCacheOptions, type RepositoryInvalidations, type RepositoryScope, type SolidDatabase, } from '@undefineds.co/drizzle-solid';
+import { createRepositoryDescriptor as createDrizzleRepositoryDescriptor, initSolidResources, initSolidTables, type AnyPodResource, type AnyPodTable, type PodRepositoryOptions as DrizzlePodRepositoryOptions } from '@undefineds.co/drizzle-solid';
+export { type PodRepositoryDescriptor, type RepositoryCacheOptions, type RepositoryInvalidations, type RepositoryScope, type SolidDatabase, } from '@undefineds.co/drizzle-solid';
+export { initSolidResources };
+export type { AnyPodResource };
+type ResourceRepositoryFilter<TResource extends AnyPodResource, Row extends Record<string, unknown>, Filters extends Record<string, unknown>> = (context: {
+    resource: TResource;
+    filters?: Filters;
+}) => ReturnType<NonNullable<DrizzlePodRepositoryOptions<TResource, Row, Filters>['filter']>>;
+export type PodResourceRepositoryOptions<TResource extends AnyPodResource, Row extends Record<string, unknown> = TResource['$inferSelect'], Filters extends Record<string, unknown> = Record<string, unknown>> = Omit<DrizzlePodRepositoryOptions<TResource, Row, Filters>, 'table' | 'filter'> & {
+    resource: TResource;
+    filter?: ResourceRepositoryFilter<TResource, Row, Filters>;
+};
+export declare function createResourceRepositoryDescriptor<TResource extends AnyPodResource, Row extends Record<string, unknown> = TResource['$inferSelect'], Insert = TResource['$inferInsert'], Update = TResource['$inferUpdate'], Filters extends Record<string, unknown> = Record<string, unknown>>(options: PodResourceRepositoryOptions<TResource, Row, Filters>): import("@undefineds.co/drizzle-solid").PodRepositoryDescriptor<TResource, Row, Insert, Update, Filters>;
+export declare const definePodRepository: typeof createResourceRepositoryDescriptor;
+export declare const createRepositoryDescriptor: typeof createDrizzleRepositoryDescriptor;
 export { initSolidTables };
 export type { AnyPodTable };
-export declare const initSolidResources: typeof initSolidTables;
-export type AnyPodResource = AnyPodTable;
 type PodResourceTemplateTarget = Parameters<typeof import('@undefineds.co/drizzle-solid').extractPodResourceTemplateValue>[0];
 export declare function asPodResourceTemplateTarget(resource: AnyPodResource): PodResourceTemplateTarget;

package/dist/repository.js

@@ -1,9 +1,20 @@
-import { initSolidTables, } from '@undefineds.co/drizzle-solid';
-export { createRepositoryDescriptor, definePodRepository, } from '@undefineds.co/drizzle-solid';
+import { createRepositoryDescriptor as createDrizzleRepositoryDescriptor, initSolidResources, initSolidTables, } from '@undefineds.co/drizzle-solid';
+export { initSolidResources };
+export function createResourceRepositoryDescriptor(options) {
+    const { resource, filter, ...rest } = options;
+    return createDrizzleRepositoryDescriptor({
+        ...rest,
+        table: resource,
+        filter: filter
+            ? ({ table, filters }) => filter({ resource: table, filters })
+            : undefined,
+    });
+}
+export const definePodRepository = createResourceRepositoryDescriptor;
+// Compatibility exports for older call sites. New shared-model code should use
+// resource names.
+export const createRepositoryDescriptor = createDrizzleRepositoryDescriptor;
 export { initSolidTables };
-// Resource-first aliases for shared Solid model call sites. The underlying
-// drizzle-solid API still uses table-shaped arguments for compatibility.
-export const initSolidResources = initSolidTables;
 export function asPodResourceTemplateTarget(resource) {
     return resource;
 }

package/dist/resource-id-defaults.d.ts

@@ -1,4 +1,3 @@
-export type CommandKind = 'chat' | 'task';
 export type DateInput = Date | string | number | null | undefined;
 export interface DateParts {
     yyyy: string;
@@ -7,15 +6,5 @@ export interface DateParts {
 }
 export declare function dateParts(value?: DateInput): DateParts;
 export declare function resourceKey(key: string | undefined, prefix: string): string;
+export declare function workflowOwnerDir(row?: Record<string, unknown>): string | null;
 export declare function parentDir(id: string | null | undefined): string | null;
-export declare function surfaceIdFromCommandResourceId(id: string | null | undefined): string | null;
-export declare function commandKindFromResourceId(id: string | null | undefined): CommandKind | null;
-export declare function chatResourceId(key?: string): string;
-export declare function taskResourceId(key?: string): string;
-export declare function threadResourceId(key: string | undefined, row?: Record<string, unknown>): string;
-export declare function messageResourceId(key: string | undefined, row?: Record<string, unknown>): string;
-export declare function runResourceId(key: string | undefined, row?: Record<string, unknown>): string;
-export declare function runStepResourceId(key: string | undefined, row?: Record<string, unknown>): string;
-export declare function matrixAccountResourceId(key: string | undefined, row?: Record<string, unknown>): string;
-export declare function matrixRoomResourceId(key: string | undefined, row?: Record<string, unknown>): string;
-export declare function matrixEventResourceId(key: string | undefined, row?: Record<string, unknown>): string;