@undefineds.co/models 0.2.25 → 0.2.27

package/dist/namespaces.js

@@ -95,6 +95,10 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     ApprovalRequest: 'ApprovalRequest',
     AuditEntry: 'AuditEntry',
     AutonomyGrant: 'AutonomyGrant',
+    Issue: 'Issue',
+    Task: 'Task',
+    Run: 'Run',
+    RunStep: 'RunStep',
     favorite: 'favorite',
     favoriteType: 'favoriteType',
     favoriteTarget: 'favoriteTarget',
@@ -113,6 +117,8 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     messageResource: 'messageResource',
     messageType: 'messageType',
     messageStatus: 'messageStatus',
+    commandKind: 'commandKind',
+    surfaceId: 'surfaceId',
     readBy: 'readBy',
     Contact: 'Contact',
     PersonContact: 'PersonContact',
@@ -153,12 +159,23 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     apiKey: 'apiKey',
     baseUrl: 'baseUrl',
     inbox: 'inbox',
+    issue: 'issue',
+    task: 'task',
+    triggerKind: 'triggerKind',
+    cron: 'cron',
+    intervalSeconds: 'intervalSeconds',
+    eventName: 'eventName',
+    nextRunAt: 'nextRunAt',
+    lastRunAt: 'lastRunAt',
+    priority: 'priority',
+    parentIssue: 'parentIssue',
     session: 'session',
     status: 'status',
     risk: 'risk',
     assignedTo: 'assignedTo',
     reason: 'reason',
     resolvedAt: 'resolvedAt',
+    closedAt: 'closedAt',
     action: 'action',
     actor: 'actor',
     actorRole: 'actorRole',
@@ -196,6 +213,18 @@ export const UDFS = createNamespace('udfs', 'https://undefineds.co/ns#', {
     policyVersion: 'policyVersion',
     parentThreadId: 'parentThreadId',
     sessionStatus: 'sessionStatus',
+    runner: 'runner',
+    prompt: 'prompt',
+    externalRunId: 'externalRunId',
+    leaseOwner: 'leaseOwner',
+    leaseExpiresAt: 'leaseExpiresAt',
+    heartbeatAt: 'heartbeatAt',
+    cancelRequestedAt: 'cancelRequestedAt',
+    startedAt: 'startedAt',
+    completedAt: 'completedAt',
+    error: 'error',
+    runId: 'runId',
+    run: 'run',
     sessionTool: 'sessionTool',
     tokenUsage: 'tokenUsage',
     groupOwner: 'groupOwner',

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

@@ -0,0 +1,189 @@
+export type PodModelDescriptorSource = 'official' | 'verified-community' | 'developer' | 'user';
+export type PodModelDescriptorTrustLevel = 'high' | 'medium' | 'low';
+export type PodModelFieldType = 'string' | 'text' | 'number' | 'boolean' | 'timestamp' | 'uri' | 'json';
+export type PodModelMergePolicy = 'create-only' | 'upsert' | 'patch' | 'append';
+export interface PodModelFieldDescriptor {
+    type: PodModelFieldType;
+    predicate: string;
+    required?: boolean;
+    secret?: boolean;
+    array?: boolean;
+    description?: string;
+}
+export interface PodModelDescriptor {
+    uri: string;
+    version: string;
+    source: PodModelDescriptorSource;
+    trustLevel: PodModelDescriptorTrustLevel;
+    namespace: string;
+    class: string;
+    resourceKind: string;
+    description: string;
+    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[];
+    writableFields: string[];
+    mergePolicy: PodModelMergePolicy;
+    examples: Array<{
+        request: string;
+        match: Record<string, unknown>;
+    }>;
+}
+export interface PodStorageMutationPlan {
+    id: string;
+    schemaUri: string;
+    operation: 'upsert';
+    resourceId: string;
+    resourceUri: string;
+    match: Record<string, unknown>;
+    set: Record<string, unknown>;
+    summary: string;
+}
+export type PodStorageValidationResult = {
+    ok: true;
+    plan: PodStorageMutationPlan;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export type PodStorageCommitResult = {
+    ok: true;
+    resource: Record<string, unknown>;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export interface PodSchemaClassEntry {
+    schemaUri: string;
+    resourceKind: string;
+    class: string;
+    namespace: string;
+    source: PodModelDescriptorSource;
+    trustLevel: PodModelDescriptorTrustLevel;
+    description: string;
+}
+export interface PodSchemaPredicateEntry {
+    schemaUri: string;
+    field: string;
+    predicate: string;
+    type: PodModelFieldType;
+    required: boolean;
+    secret: boolean;
+    array: boolean;
+    description?: string;
+}
+export interface PodSchemaSearchEntry {
+    uri: string;
+    resourceKind: string;
+    class: string;
+    namespace: string;
+    source: PodModelDescriptorSource;
+    trustLevel: PodModelDescriptorTrustLevel;
+    description: string;
+    score: number;
+    matchedFields: string[];
+}
+export declare const credentialDescriptor: PodModelDescriptor;
+export declare const officialPodModelDescriptors: readonly [PodModelDescriptor];
+export declare function createPodModelDescriptorRegistry(descriptors?: readonly PodModelDescriptor[]): {
+    list(filter?: {
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+    }): PodModelDescriptor[];
+    describe(uri: string): PodModelDescriptor | null;
+};
+export declare const podSchema: {
+    list: (filter?: {
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+    }) => PodModelDescriptor[];
+    describe(uriOrInput: string | {
+        uri: string;
+    } | {
+        schemaUri: string;
+    }): PodModelDescriptor | null;
+    classes(input?: {
+        uri?: string;
+        schemaUri?: string;
+    }): PodSchemaClassEntry[];
+    search(input: {
+        query: string;
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+        limit?: number;
+    }): PodSchemaSearchEntry[];
+    predicates(input?: {
+        uri?: string;
+        schemaUri?: string;
+        field?: string;
+    }): PodSchemaPredicateEntry[];
+};
+export declare function createPodSchema(registry?: {
+    list(filter?: {
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+    }): PodModelDescriptor[];
+    describe(uri: string): PodModelDescriptor | null;
+}): {
+    list: (filter?: {
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+    }) => PodModelDescriptor[];
+    describe(uriOrInput: string | {
+        uri: string;
+    } | {
+        schemaUri: string;
+    }): PodModelDescriptor | null;
+    classes(input?: {
+        uri?: string;
+        schemaUri?: string;
+    }): PodSchemaClassEntry[];
+    search(input: {
+        query: string;
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+        limit?: number;
+    }): PodSchemaSearchEntry[];
+    predicates(input?: {
+        uri?: string;
+        schemaUri?: string;
+        field?: string;
+    }): PodSchemaPredicateEntry[];
+};
+export declare function createPodStorage(registry?: {
+    list(filter?: {
+        source?: PodModelDescriptorSource;
+        resourceKind?: string;
+    }): PodModelDescriptor[];
+    describe(uri: string): PodModelDescriptor | null;
+}, store?: Map<string, Record<string, unknown>>): {
+    validate(input: {
+        schemaUri?: string;
+        operation: "upsert";
+        match: Record<string, unknown>;
+        set?: Record<string, unknown>;
+    }): PodStorageValidationResult;
+    commit(input: {
+        planId: string;
+    }): PodStorageCommitResult;
+    read(input: {
+        resourceUri: string;
+    }): PodStorageCommitResult;
+    store: Map<string, Record<string, unknown>>;
+    plans: Map<string, PodStorageMutationPlan>;
+};

package/dist/pod-storage-descriptor.js

@@ -0,0 +1,283 @@
+import { XPOD_CREDENTIAL } from './namespaces.js';
+export const credentialDescriptor = {
+    uri: XPOD_CREDENTIAL.Credential,
+    version: '1.0.0',
+    source: 'official',
+    trustLevel: 'high',
+    namespace: XPOD_CREDENTIAL.NAMESPACE,
+    class: XPOD_CREDENTIAL.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'),
+            required: true,
+            description: 'Local credential id.',
+        },
+        service: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.service,
+            required: true,
+            description: 'Credential service grouping, for example ai or infra.',
+        },
+        providerId: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.provider,
+            required: true,
+            description: 'Provider identifier such as openai or cloudflare.',
+        },
+        secretType: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.term('secretType'),
+            required: true,
+            description: 'Provider-specific secret kind such as api-key or tunnel-token.',
+        },
+        label: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.label,
+            description: 'User-facing credential label.',
+        },
+        apiKey: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.apiKey,
+            secret: true,
+            description: 'Secret token or API key material.',
+        },
+        status: {
+            type: 'string',
+            predicate: XPOD_CREDENTIAL.status,
+            description: 'Credential health status.',
+        },
+    },
+    uniqueBy: ['service', 'providerId', 'secretType'],
+    writableFields: ['label', 'apiKey', 'status'],
+    mergePolicy: 'upsert',
+    examples: [
+        {
+            request: '保存 Cloudflare tunnel token',
+            match: {
+                service: 'infra',
+                providerId: 'cloudflare',
+                secretType: 'tunnel-token',
+            },
+        },
+        {
+            request: '保存 OpenAI API key',
+            match: {
+                service: 'ai',
+                providerId: 'openai',
+                secretType: 'api-key',
+            },
+        },
+    ],
+};
+export const officialPodModelDescriptors = [credentialDescriptor];
+export function createPodModelDescriptorRegistry(descriptors = officialPodModelDescriptors) {
+    const byUri = new Map(descriptors.map((descriptor) => [descriptor.uri, descriptor]));
+    return {
+        list(filter = {}) {
+            return descriptors.filter((descriptor) => {
+                if (filter.source && descriptor.source !== filter.source)
+                    return false;
+                if (filter.resourceKind && descriptor.resourceKind !== filter.resourceKind)
+                    return false;
+                return true;
+            });
+        },
+        describe(uri) {
+            return byUri.get(uri) ?? null;
+        },
+    };
+}
+export const podSchema = createPodSchema();
+export function createPodSchema(registry = createPodModelDescriptorRegistry()) {
+    const resolveDescriptors = (input = {}) => {
+        const uri = input.uri ?? input.schemaUri;
+        if (!uri)
+            return registry.list();
+        const descriptor = registry.describe(uri);
+        return descriptor ? [descriptor] : [];
+    };
+    return {
+        list: registry.list,
+        describe(uriOrInput) {
+            const uri = typeof uriOrInput === 'string'
+                ? uriOrInput
+                : 'uri' in uriOrInput
+                    ? uriOrInput.uri
+                    : uriOrInput.schemaUri;
+            return registry.describe(uri);
+        },
+        classes(input = {}) {
+            return resolveDescriptors(input).map((descriptor) => ({
+                schemaUri: descriptor.uri,
+                resourceKind: descriptor.resourceKind,
+                class: descriptor.class,
+                namespace: descriptor.namespace,
+                source: descriptor.source,
+                trustLevel: descriptor.trustLevel,
+                description: descriptor.description,
+            }));
+        },
+        search(input) {
+            const terms = normalizeSearchTerms(input.query);
+            if (terms.length === 0)
+                return [];
+            return registry.list({
+                source: input.source,
+                resourceKind: input.resourceKind,
+            })
+                .map((descriptor) => scoreDescriptorSearch(descriptor, terms))
+                .filter((entry) => entry !== null)
+                .sort((a, b) => b.score - a.score || a.uri.localeCompare(b.uri))
+                .slice(0, Math.max(1, input.limit ?? 10));
+        },
+        predicates(input = {}) {
+            return resolveDescriptors(input).flatMap((descriptor) => (Object.entries(descriptor.fields)
+                .filter(([field]) => !input.field || field === input.field)
+                .map(([field, descriptorField]) => ({
+                schemaUri: descriptor.uri,
+                field,
+                predicate: descriptorField.predicate,
+                type: descriptorField.type,
+                required: Boolean(descriptorField.required),
+                secret: Boolean(descriptorField.secret),
+                array: Boolean(descriptorField.array),
+                description: descriptorField.description,
+            }))));
+        },
+    };
+}
+export function createPodStorage(registry = createPodModelDescriptorRegistry(), store = new Map()) {
+    const plans = new Map();
+    return {
+        validate(input) {
+            const schemaUri = input.schemaUri;
+            if (!schemaUri)
+                return invalid('schema_uri_required', 'Missing schemaUri');
+            const descriptor = registry.describe(schemaUri);
+            if (!descriptor)
+                return invalid('descriptor_not_found', `Descriptor not found: ${schemaUri}`);
+            if (input.operation !== 'upsert')
+                return invalid('unsupported_operation', `Unsupported operation: ${input.operation}`);
+            const missingKeys = descriptor.uniqueBy.filter((field) => !input.match[field]);
+            if (missingKeys.length > 0) {
+                return invalid('missing_match_fields', `Missing match fields: ${missingKeys.join(', ')}`);
+            }
+            const set = input.set ?? {};
+            const invalidSetFields = Object.keys(set).filter((field) => !descriptor.writableFields.includes(field));
+            if (invalidSetFields.length > 0) {
+                return invalid('invalid_set_fields', `Fields are not writable: ${invalidSetFields.join(', ')}`);
+            }
+            const resourceId = buildResourceId(descriptor, input.match);
+            const plan = {
+                id: `plan_${resourceId.replace(/[^a-zA-Z0-9_.-]+/g, '-')}`,
+                schemaUri: descriptor.uri,
+                operation: input.operation,
+                resourceId,
+                resourceUri: buildResourceUri(descriptor, resourceId),
+                match: input.match,
+                set,
+                summary: `Upsert ${descriptor.resourceKind} for ${descriptor.uniqueBy.map((field) => input.match[field]).join('/')}`,
+            };
+            plans.set(plan.id, plan);
+            return { ok: true, plan };
+        },
+        commit(input) {
+            const plan = plans.get(input.planId);
+            if (!plan)
+                return invalid('plan_not_found', `Plan not found: ${input.planId}`);
+            const existing = store.get(plan.resourceUri) ?? {};
+            const resource = {
+                ...existing,
+                ...plan.match,
+                ...plan.set,
+                schemaUri: plan.schemaUri,
+                resourceId: plan.resourceId,
+                resourceUri: plan.resourceUri,
+            };
+            store.set(plan.resourceUri, resource);
+            return { ok: true, resource };
+        },
+        read(input) {
+            const resource = store.get(input.resourceUri);
+            if (!resource)
+                return invalid('resource_not_found', `Resource not found: ${input.resourceUri}`);
+            return { ok: true, resource };
+        },
+        store,
+        plans,
+    };
+}
+function invalid(code, message) {
+    return {
+        ok: false,
+        error: { code, message },
+    };
+}
+function buildResourceId(descriptor, match) {
+    const raw = descriptor.uniqueBy.map((field) => String(match[field])).join('-');
+    const localId = raw.replace(/[^a-zA-Z0-9_.-]+/g, '-');
+    return descriptor.storage.resourceIdPattern.replace('{id}', localId);
+}
+function buildResourceUri(descriptor, resourceId) {
+    return `${descriptor.storage.base}${resourceId}`;
+}
+function normalizeSearchTerms(query) {
+    return query
+        .toLowerCase()
+        .split(/[\s,;:/#._-]+/u)
+        .map((term) => term.trim())
+        .filter(Boolean);
+}
+function scoreDescriptorSearch(descriptor, terms) {
+    const matchedFields = new Set();
+    let score = 0;
+    const match = (field, value, weight) => {
+        if (!value)
+            return;
+        const normalized = value.toLowerCase();
+        for (const term of terms) {
+            if (!normalized.includes(term))
+                continue;
+            matchedFields.add(field);
+            score += weight;
+        }
+    };
+    match('uri', descriptor.uri, 10);
+    match('class', descriptor.class, 10);
+    match('namespace', descriptor.namespace, 4);
+    match('resourceKind', descriptor.resourceKind, 8);
+    match('description', descriptor.description, 4);
+    match('storage', `${descriptor.storage.base}${descriptor.storage.resourceIdPattern}`, 3);
+    for (const [fieldName, field] of Object.entries(descriptor.fields)) {
+        match(`field:${fieldName}`, fieldName, 6);
+        match(`predicate:${fieldName}`, field.predicate, 6);
+        match(`description:${fieldName}`, field.description, 3);
+    }
+    for (const example of descriptor.examples) {
+        match('example', example.request, 3);
+        for (const [fieldName, value] of Object.entries(example.match)) {
+            match(`example:${fieldName}`, String(value), 3);
+        }
+    }
+    if (score <= 0)
+        return null;
+    return {
+        uri: descriptor.uri,
+        resourceKind: descriptor.resourceKind,
+        class: descriptor.class,
+        namespace: descriptor.namespace,
+        source: descriptor.source,
+        trustLevel: descriptor.trustLevel,
+        description: descriptor.description,
+        score,
+        matchedFields: [...matchedFields].sort(),
+    };
+}

package/dist/repository.d.ts

@@ -4,3 +4,5 @@ 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

@@ -4,3 +4,6 @@ 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

@@ -0,0 +1,18 @@
+export type CommandKind = 'chat' | 'task';
+export type DateInput = Date | string | number | null | undefined;
+export interface DateParts {
+    yyyy: string;
+    MM: string;
+    dd: string;
+}
+export declare function dateParts(value?: DateInput): DateParts;
+export declare function resourceKey(key: string | undefined, prefix: string): string;
+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;

package/dist/resource-id-defaults.js

@@ -0,0 +1,84 @@
+export function dateParts(value) {
+    const date = value instanceof Date
+        ? value
+        : typeof value === 'string' || typeof value === 'number'
+            ? new Date(typeof value === 'number' && Math.abs(value) < 100000000000 ? value * 1000 : value)
+            : new Date();
+    const safeDate = Number.isFinite(date.getTime()) ? date : new Date();
+    return {
+        yyyy: String(safeDate.getUTCFullYear()),
+        MM: String(safeDate.getUTCMonth() + 1).padStart(2, '0'),
+        dd: String(safeDate.getUTCDate()).padStart(2, '0'),
+    };
+}
+export function resourceKey(key, prefix) {
+    return key && key.length > 0
+        ? key
+        : `${prefix}_${Math.random().toString(36).slice(2, 12)}`;
+}
+export function parentDir(id) {
+    if (!id)
+        return null;
+    const hashless = id.split('#')[0] ?? id;
+    const parts = hashless.split('/').filter(Boolean);
+    if (parts.length <= 1)
+        return null;
+    return parts.slice(0, -1).join('/');
+}
+export function surfaceIdFromCommandResourceId(id) {
+    if (!id)
+        return null;
+    const match = id.match(/^(chat|task)\/([^/]+)\//);
+    return match ? decodeURIComponent(match[2]) : null;
+}
+export function commandKindFromResourceId(id) {
+    if (!id)
+        return null;
+    const match = id.match(/^(chat|task)\//);
+    return match?.[1] === 'task' ? 'task' : match?.[1] === 'chat' ? 'chat' : null;
+}
+export function chatResourceId(key) {
+    return `${resourceKey(key, 'chat')}/index.ttl#this`;
+}
+export function taskResourceId(key) {
+    return `index.ttl#${resourceKey(key, 'task')}`;
+}
+export function threadResourceId(key, row) {
+    const localKey = resourceKey(key, 'thread');
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : surfaceIdFromCommandResourceId(typeof row?.id === 'string' ? row.id : undefined) ?? 'default';
+    return `${commandKind}/${surfaceId}/index.ttl#${localKey}`;
+}
+export function messageResourceId(key, row) {
+    const localKey = resourceKey(key, 'msg');
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : surfaceIdFromCommandResourceId(typeof row?.thread === 'string' ? row.thread : undefined) ?? 'default';
+    const { yyyy, MM, dd } = dateParts(row?.createdAt);
+    return `${commandKind}/${surfaceId}/${yyyy}/${MM}/${dd}/messages.ttl#${localKey}`;
+}
+export function runResourceId(key, row) {
+    const localKey = resourceKey(key, 'run');
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : surfaceIdFromCommandResourceId(typeof row?.thread === 'string' ? row.thread : undefined) ?? 'default';
+    const { yyyy, MM, dd } = dateParts(row?.createdAt);
+    return `${commandKind}/${surfaceId}/${yyyy}/${MM}/${dd}/runs.ttl#${localKey}`;
+}
+export function runStepResourceId(key, row) {
+    const localKey = resourceKey(key, 'run-step');
+    const runId = typeof row?.runId === 'string' ? row.runId : undefined;
+    if (runId && /^(chat|task)\/[^/]+\/\d{4}\/\d{2}\/\d{2}\/runs\.ttl#[^#/]+$/.test(runId)) {
+        return `${runId.slice(0, runId.lastIndexOf('#') + 1)}${localKey}`;
+    }
+    const commandKind = row?.commandKind === 'task' ? 'task' : 'chat';
+    const surfaceId = typeof row?.surfaceId === 'string' && row.surfaceId.length > 0
+        ? row.surfaceId
+        : 'default';
+    const { yyyy, MM, dd } = dateParts(row?.createdAt);
+    return `${commandKind}/${surfaceId}/${yyyy}/${MM}/${dd}/runs.ttl#${localKey}`;
+}