@undefineds.co/xpod 0.4.17 → 0.4.19

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/aggregates.d.ts

@@ -0,0 +1,19 @@
+import { PodColumnBase } from './schema';
+export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export interface AggregateExpression {
+    kind: 'aggregate';
+    func: AggregateFunction;
+    column?: PodColumnBase | string;
+    distinct?: boolean;
+}
+interface AggregateOptions {
+    distinct?: boolean;
+}
+export declare function count(column?: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
+export declare function sum(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
+export declare function avg(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
+export declare function min(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
+export declare function max(column: PodColumnBase | string, options?: AggregateOptions): AggregateExpression;
+export declare function isAggregateExpression(value: unknown): value is AggregateExpression;
+export {};
+//# sourceMappingURL=aggregates.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/ast-to-sparql.d.ts

@@ -0,0 +1,66 @@
+import { SQL } from 'drizzle-orm';
+import { PodColumnBase, PodTable } from './schema';
+import { SPARQLQuery } from './sparql/types';
+import { SelectQueryPlan } from './select-plan';
+import { QueryCondition } from './query-conditions';
+import type { UriResolver } from './uri';
+export type { SPARQLQuery };
+interface SimpleSelectOperation {
+    table: PodTable;
+    where?: Record<string, unknown>;
+    limit?: number;
+    offset?: number;
+    orderBy?: Array<{
+        column: string;
+        direction: 'asc' | 'desc';
+    }>;
+    distinct?: boolean;
+}
+interface InsertPlanInput {
+    table: PodTable;
+    rows: Array<Record<string, unknown>>;
+}
+/**
+ * Table registry context for URI resolution
+ */
+export interface TableRegistryContext {
+    tableRegistry: Map<string, PodTable[]>;
+    tableNameRegistry: Map<string, PodTable>;
+    baseUri?: string;
+    record?: Record<string, unknown>;
+    currentTable?: PodTable;
+}
+export declare class ASTToSPARQLConverter {
+    private podUrl;
+    private webId?;
+    private selectBuilder;
+    private updateBuilder;
+    private expressionBuilder;
+    private tableContext?;
+    private uriResolver;
+    private prefixes;
+    constructor(podUrl: string, webId?: string | undefined, uriResolver?: UriResolver);
+    /**
+     * Set table registry for URI link resolution
+     */
+    setTableRegistry(tableRegistry: Map<string, PodTable[]>, tableNameRegistry: Map<string, PodTable>, baseUri?: string): void;
+    convertSelect(ast: Record<string, unknown>, table: PodTable, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
+    buildWhereClauseForCondition(whereAst: QueryCondition, table: PodTable): string;
+    convertSelectPlan(plan: SelectQueryPlan, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
+    convertSimpleSelect(operation: SimpleSelectOperation, targetGraph?: string, fromSources?: string[], allowGraphVariable?: boolean): SPARQLQuery;
+    convertInsert(valuesOrPlan: Array<Record<string, unknown>> | InsertPlanInput, table?: PodTable, targetGraph?: string): SPARQLQuery;
+    convertUpdate(setData: Record<string, unknown>, whereConditions: QueryCondition | Record<string, unknown>, table: PodTable, targetGraph?: string): SPARQLQuery;
+    convertDelete(whereConditions: QueryCondition | Record<string, unknown>, table: PodTable, targetGraph?: string): SPARQLQuery;
+    getPrefixes(): Record<string, string>;
+    addPrefix(prefix: string, uri: string): void;
+    getPredicateForColumnPublic(column: PodColumnBase | string | Record<string, unknown>, table: PodTable): string;
+    formatLiteralValue(value: unknown, column?: PodColumnBase | Record<string, unknown>): string | string[];
+    generateSubjectUri(record: Record<string, unknown>, table: PodTable): string;
+    parseDrizzleAST(sql: SQL, _table?: PodTable): {
+        type: 'select';
+        columns: '*';
+        where: Record<string, never>;
+    };
+    private parseWhereClause;
+}
+//# sourceMappingURL=ast-to-sparql.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/compile-time-types.d.ts

@@ -0,0 +1,40 @@
+import { PodTable, PodTableOptions } from './schema';
+type AnyTypedField = TypedField<string>;
+type TypedFieldMap = Record<string, AnyTypedField>;
+export interface TypedField<T extends string> {
+    name: T;
+    predicate: string;
+    type: 'string' | 'number' | 'boolean' | 'Date';
+    primaryKey?: boolean;
+}
+export type TypedTableDefinition<T extends TypedFieldMap> = {
+    [K in keyof T]: T[K];
+};
+export declare function createTypedTable<T extends TypedFieldMap>(name: string, definition: TypedTableDefinition<T>, options: PodTableOptions): PodTable;
+export declare function field<T extends string>(name: T, predicate: string, type: 'string' | 'number' | 'boolean' | 'Date', options?: {
+    primaryKey?: boolean;
+}): TypedField<T>;
+export declare const CommonFields: {
+    readonly name: (predicate?: string) => TypedField<"name">;
+    readonly email: (predicate?: string) => TypedField<"email">;
+    readonly age: (predicate?: string) => TypedField<"age">;
+    readonly dateCreated: (predicate?: string) => TypedField<"dateCreated">;
+    readonly isActive: (predicate?: string) => TypedField<"isActive">;
+    readonly url: (predicate?: string) => TypedField<"url">;
+    readonly description: (predicate?: string) => TypedField<"description">;
+    readonly identifier: (predicate?: string) => TypedField<"identifier">;
+};
+export declare class TypedTableBuilder<T extends TypedFieldMap> {
+    private name;
+    private options;
+    private definition;
+    constructor(name: string, options: PodTableOptions, definition?: TypedTableDefinition<T>);
+    addField<K extends string>(fieldDef: TypedField<K>): TypedTableBuilder<T & Record<K, TypedField<K>>>;
+    build(): PodTable;
+}
+export declare function typedTable(name: string, options: PodTableOptions): TypedTableBuilder<Record<string, never>>;
+export type TypedTableResult<T extends TypedFieldMap> = {
+    [K in keyof T]: T[K] extends TypedField<string> ? T[K]['type'] extends 'string' ? string : T[K]['type'] extends 'number' ? number : T[K]['type'] extends 'boolean' ? boolean : T[K]['type'] extends 'Date' ? Date : never : never;
+};
+export {};
+//# sourceMappingURL=compile-time-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/comunica-patch.d.ts

@@ -0,0 +1,2 @@
+export declare const applyComunicaPatches: (requireModule?: NodeRequire | null) => boolean;
+//# sourceMappingURL=comunica-patch.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/conflict-resolution.d.ts

@@ -0,0 +1,110 @@
+import { SolidDataset, Thing } from '@inrupt/solid-client';
+/**
+ * 合并策略类型
+ */
+export type MergeStrategy = 'last-write-wins' | 'field-level-merge' | 'timestamp-based' | 'user-resolution';
+/**
+ * 冲突解析配置
+ */
+export interface ConflictResolutionConfig {
+    /** 最大重试次数 */
+    maxRetries?: number;
+    /** 合并策略 */
+    strategy?: MergeStrategy;
+    /** 用户自定义解析函数（当 strategy = 'user-resolution' 时使用） */
+    resolver?: (local: Thing, remote: Thing, predicates: string[]) => Thing;
+    /** 重试延迟（毫秒） */
+    retryDelay?: number;
+    /** 是否启用日志 */
+    logging?: boolean;
+}
+/**
+ * 冲突解析结果
+ */
+export interface ConflictResolutionResult {
+    success: boolean;
+    retries: number;
+    strategy?: string;
+    error?: string;
+}
+/**
+ * 并发写入冲突解析器
+ *
+ * 处理 412 Precondition Failed 错误（ETag 不匹配），
+ * 通过不同的合并策略自动重试保存操作。
+ */
+export declare class ConflictResolver {
+    private config;
+    private fetchFn;
+    constructor(fetchFn: typeof fetch, config?: ConflictResolutionConfig);
+    /**
+     * 执行带冲突解析的保存操作
+     *
+     * @param resourceUrl - 资源 URL
+     * @param modifier - 修改函数，接收当前 dataset 并返回修改后的 dataset
+     * @returns 解析结果
+     */
+    saveWithRetry(resourceUrl: string, modifier: (dataset: SolidDataset) => SolidDataset | Promise<SolidDataset>): Promise<ConflictResolutionResult>;
+    /**
+     * 执行带字段级合并的保存操作
+     *
+     * @param resourceUrl - 资源 URL
+     * @param thingUrl - Thing URL
+     * @param localChanges - 本地修改的 Thing
+     * @param predicates - 需要更新的谓词列表
+     * @returns 解析结果
+     */
+    saveThingWithMerge(resourceUrl: string, thingUrl: string, localChanges: Thing, predicates: string[]): Promise<ConflictResolutionResult>;
+    /**
+     * 合并两个 Thing
+     *
+     * @param local - 本地版本（包含我们的修改）
+     * @param remote - 远程版本（最新状态）
+     * @param predicates - 需要合并的谓词列表
+     * @returns 合并后的 Thing
+     */
+    private mergeThings;
+    /**
+     * 字段级合并
+     *
+     * 策略：
+     * - 对于 predicates 中的谓词，使用本地版本
+     * - 对于其他谓词，保留远程版本
+     */
+    private fieldLevelMerge;
+    /**
+     * 基于时间戳的合并
+     *
+     * 策略：
+     * - 如果有 updatedAt 字段，比较时间戳，选择最新的
+     * - 否则 fallback 到 field-level-merge
+     */
+    private timestampBasedMerge;
+    /**
+     * 获取 Thing 的 updatedAt 时间戳
+     */
+    private getUpdatedAt;
+    /**
+     * 获取谓词的值（支持多种类型）
+     */
+    private getPredicateValue;
+    /**
+     * 设置谓词的值（根据类型）
+     *
+     * 注意：这是简化实现，实际使用时应该用 buildThing 模式
+     */
+    private setPredicateValue;
+    /**
+     * 延迟函数
+     */
+    private delay;
+}
+/**
+ * 便捷函数：使用默认配置创建冲突解析器
+ */
+export declare function createConflictResolver(fetchFn: typeof fetch, config?: ConflictResolutionConfig): ConflictResolver;
+/**
+ * 便捷函数：执行单次带重试的保存操作
+ */
+export declare function saveWithConflictResolution(fetchFn: typeof fetch, resourceUrl: string, modifier: (dataset: SolidDataset) => SolidDataset | Promise<SolidDataset>, config?: ConflictResolutionConfig): Promise<ConflictResolutionResult>;
+//# sourceMappingURL=conflict-resolution.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/composite-discovery.d.ts

@@ -0,0 +1,18 @@
+import { PodTable } from '../schema';
+import { DataDiscovery, DataLocation, DiscoverOptions, RegisterOptions, DataRegistrationInfo } from './types';
+export declare class CompositeDiscovery implements DataDiscovery {
+    private strategies;
+    constructor(strategies: DataDiscovery[]);
+    register(table: PodTable, options?: RegisterOptions): Promise<void>;
+    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
+    isRegistered(rdfClass: string): Promise<boolean>;
+    /**
+     * 获取所有数据注册 - 聚合所有支持此方法的策略结果
+     */
+    discoverAll(): Promise<DataRegistrationInfo[]>;
+    /**
+     * 按应用 ID 发现数据位置 - 聚合所有支持此方法的策略结果
+     */
+    discoverByApp(appId: string): Promise<DataLocation[]>;
+}
+//# sourceMappingURL=composite-discovery.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './typeindex-discovery';
+export * from './interop-discovery';
+export * from './interop-types';
+export * from './composite-discovery';
+export * from './provider-cache';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/interop-discovery.d.ts

@@ -0,0 +1,36 @@
+import { PodTable } from '../schema';
+import { DataDiscovery, DataLocation, DiscoverOptions, DataRegistrationInfo, RegisterOptions } from './types';
+export declare class InteropDiscovery implements DataDiscovery {
+    private webId;
+    private fetchFn;
+    private clientId?;
+    private shapeTreeCache;
+    constructor(webId: string, fetchFn: typeof fetch, clientId?: string | undefined);
+    private ensureRegistrySet;
+    register(table: PodTable, options?: RegisterOptions): Promise<void>;
+    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
+    /**
+     * 按 container 合并原始结果
+     * 同一个 container 的多个 Shape 合并到 shapes 数组中
+     */
+    private mergeByContainer;
+    private discoverDataRegistrationsRaw;
+    private discoverAccessGrantsRaw;
+    isRegistered(rdfClass: string): Promise<boolean>;
+    /**
+     * 按应用 ID 发现所有数据位置
+     * @param appId 应用标识符
+     */
+    discoverByApp(appId: string): Promise<DataLocation[]>;
+    /**
+     * 获取所有数据注册
+     */
+    discoverAll(): Promise<DataRegistrationInfo[]>;
+    private checkShapeTreeMatchesClass;
+    /**
+     * 解析 ShapeTree，获取 expectsType 和 shape URL
+     * 结果会被缓存以提高性能
+     */
+    private resolveShapeTree;
+}
+//# sourceMappingURL=interop-discovery.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/interop-tables.d.ts

@@ -0,0 +1,37 @@
+export declare const registrySetSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    hasDataRegistry: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+    hasAgentRegistry: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+}>>;
+export declare const dataRegistrySchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    hasDataRegistration: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+}>>;
+export declare const dataRegistrationSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    registeredShapeTree: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    registeredBy: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    registeredAt: import("../schema").ColumnBuilder<"string", null, false, false>;
+    subjectTemplate: import("../schema").ColumnBuilder<"string", null, false, false>;
+}>>;
+export declare const applicationRegistrationSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    registeredAgent: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    hasAccessGrant: import("../schema").ColumnBuilder<"uri", null, false, false>;
+}>>;
+export declare const accessGrantSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    grantedBy: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    grantedAt: import("../schema").ColumnBuilder<"string", null, false, false>;
+    grantee: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    hasDataGrant: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+}>>;
+export declare const dataGrantSchema: import("../schema").SolidSchema<import("../schema").ResolvedColumns<{
+    id: import("../schema").PodStringColumn<false, false>;
+    registeredShapeTree: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    hasDataRegistration: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    scopeOfGrant: import("../schema").ColumnBuilder<"uri", null, false, false>;
+    accessMode: import("../schema").ColumnBuilder<"array", "uri", false, false>;
+    dataOwner: import("../schema").ColumnBuilder<"uri", null, false, false>;
+}>>;
+//# sourceMappingURL=interop-tables.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/interop-types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Solid Application Interoperability (SAI) 相关的常量和类型定义
+ */
+export declare const INTEROP: {
+    readonly NS: "http://www.w3.org/ns/solid/interop#";
+    readonly ApplicationRegistration: "http://www.w3.org/ns/solid/interop#ApplicationRegistration";
+    readonly DataRegistration: "http://www.w3.org/ns/solid/interop#DataRegistration";
+    readonly AccessGrant: "http://www.w3.org/ns/solid/interop#AccessGrant";
+    readonly DataGrant: "http://www.w3.org/ns/solid/interop#DataGrant";
+    readonly RegistrySet: "http://www.w3.org/ns/solid/interop#RegistrySet";
+    readonly DataRegistry: "http://www.w3.org/ns/solid/interop#DataRegistry";
+    readonly hasRegistrySet: "http://www.w3.org/ns/solid/interop#hasRegistrySet";
+    readonly hasDataRegistry: "http://www.w3.org/ns/solid/interop#hasDataRegistry";
+    readonly hasDataRegistration: "http://www.w3.org/ns/solid/interop#hasDataRegistration";
+    readonly registeredShapeTree: "http://www.w3.org/ns/solid/interop#registeredShapeTree";
+    readonly registeredBy: "http://www.w3.org/ns/solid/interop#registeredBy";
+    readonly hasAccessGrant: "http://www.w3.org/ns/solid/interop#hasAccessGrant";
+    readonly hasDataGrant: "http://www.w3.org/ns/solid/interop#hasDataGrant";
+    readonly scopeOfGrant: "http://www.w3.org/ns/solid/interop#scopeOfGrant";
+    readonly dataOwner: "http://www.w3.org/ns/solid/interop#dataOwner";
+    readonly registeredShapeTreeProp: "http://www.w3.org/ns/solid/interop#registeredShapeTree";
+};
+export declare const SHAPETREES: {
+    readonly NS: "http://www.w3.org/ns/shapetrees#";
+    readonly ShapeTree: "http://www.w3.org/ns/shapetrees#ShapeTree";
+    readonly expectsType: "http://www.w3.org/ns/shapetrees#expectsType";
+    readonly shape: "http://www.w3.org/ns/shapetrees#shape";
+};
+/**
+ * Undefineds.co vocabulary extensions for Solid
+ */
+export declare const UDFS: {
+    readonly NS: "https://vocab.undefineds.co/";
+    readonly subjectTemplate: "https://vocab.undefineds.co/subjectTemplate";
+};
+//# sourceMappingURL=interop-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/provider-cache.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Provider Cache
+ *
+ * 缓存 Pod 供应商的 .well-known/solid 响应
+ * 同一供应商的用户共享缓存，减少重复请求
+ */
+/**
+ * .well-known/solid 响应内容
+ */
+export interface WellKnownResponse {
+    /** 公开 TypeIndex 位置 */
+    typeIndex?: string;
+    /** 私有 TypeIndex 位置 */
+    privateTypeIndex?: string;
+    /** SAI Registry Set 位置 */
+    registrySet?: string;
+    /** OIDC Issuer */
+    oidcIssuer?: string;
+    /** 原始响应（保留未来扩展字段） */
+    raw?: Record<string, string>;
+}
+export declare class ProviderCache {
+    private cache;
+    private ttl;
+    private fetchFn;
+    constructor(options?: {
+        ttl?: number;
+        fetch?: typeof fetch;
+    });
+    /**
+     * 获取 Pod 的 .well-known 信息
+     * 优先使用缓存
+     */
+    getWellKnown(podUrl: string): Promise<WellKnownResponse>;
+    /**
+     * 发现指定类型的数据位置
+     * SAI 优先，TypeIndex 兜底
+     */
+    discover(podUrl: string, type: string, discoverFromSAI: (registrySet: string, type: string) => Promise<string | null>, discoverFromTypeIndex: (typeIndex: string, type: string) => Promise<string | null>): Promise<string | null>;
+    /**
+     * 设置 TTL
+     */
+    setTTL(ms: number): void;
+    /**
+     * 清除缓存
+     */
+    clear(): void;
+    /**
+     * 清除指定供应商的缓存
+     */
+    clearProvider(provider: string): void;
+    /**
+     * 从 Pod URL 提取供应商标识
+     * https://bob.solidcommunity.net/ → solidcommunity.net
+     * https://alice.inrupt.net/ → inrupt.net
+     */
+    private extractProvider;
+    /**
+     * 请求 .well-known/solid
+     */
+    private fetchWellKnown;
+    /**
+     * 解析 Turtle 格式的 .well-known/solid
+     */
+    private parseTurtle;
+    /**
+     * 从行中提取 URL
+     */
+    private extractUrl;
+    /**
+     * 解析 JSON-LD 格式
+     */
+    private parseJsonLd;
+    /**
+     * 从 JSON-LD 值中提取 URL
+     */
+    private extractJsonLdValue;
+    /**
+     * 解析 URL（处理相对路径）
+     */
+    private resolveUrl;
+    /**
+     * 从完整 URL 提取相对路径
+     */
+    private extractPaths;
+    /**
+     * 将完整 URL 转换为相对路径
+     */
+    private toRelativePath;
+    /**
+     * 将缓存的相对路径应用到指定 Pod
+     */
+    private applyToPod;
+    /**
+     * 将相对路径转换为完整 URL
+     */
+    private toAbsoluteUrl;
+}
+//# sourceMappingURL=provider-cache.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/typeindex-discovery.d.ts

@@ -0,0 +1,32 @@
+import { PodTable } from '../schema';
+import { TypeIndexManager } from '../typeindex-manager';
+import { DataDiscovery, DataLocation, DiscoverOptions, RegisterOptions } from './types';
+import type { UriResolver } from '../uri';
+/**
+ * 基于 TypeIndex 的数据发现实现
+ */
+export declare class TypeIndexDiscovery implements DataDiscovery {
+    private manager;
+    private podUrl;
+    private uriResolver;
+    constructor(manager: TypeIndexManager, podUrl: string, uriResolver?: UriResolver);
+    setPodUrl(podUrl: string): void;
+    private getPodUrl;
+    /**
+     * 注册表的类型到 TypeIndex
+     */
+    register(table: PodTable, _options?: RegisterOptions): Promise<void>;
+    /**
+     * 发现某类型数据的位置
+     */
+    discover(rdfClass: string, _options?: DiscoverOptions): Promise<DataLocation[]>;
+    /**
+     * 检查类型是否已注册
+     */
+    isRegistered(rdfClass: string): Promise<boolean>;
+    private getRdfClass;
+    private resolveTableResource;
+    private toAbsolute;
+    private handleRegistrationError;
+}
+//# sourceMappingURL=typeindex-discovery.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/discovery/types.d.ts

@@ -0,0 +1,132 @@
+import { PodTable } from '../schema';
+/**
+ * 数据注册选项
+ */
+export interface RegisterOptions {
+    /** RegistrySet 基础路径（用于自动创建 SAI registry） */
+    registryPath?: string;
+    /** Shape URL - 如果提供，会在 ShapeTree 中引用此 Shape */
+    shapeUrl?: string;
+    /** 自定义容器路径（相对于 DataRegistry） */
+    containerSlug?: string;
+    /** 是否强制重新注册（即使已存在） */
+    force?: boolean;
+}
+/**
+ * Shape 信息
+ */
+export interface ShapeInfo {
+    /** Shape URL - 实际的 SHACL Shape 定义位置 */
+    url: string;
+    /** ShapeTree URL - SAI 发现时的 ShapeTree 位置 */
+    shapeTree?: string;
+    /** 注册此 Shape 的应用 ID (clientId/appId) */
+    registeredBy?: string;
+    /** 发现来源 */
+    source: 'typeindex' | 'interop' | 'config';
+}
+/**
+ * 数据位置信息 - 以 container 为准
+ *
+ * 一个 container 可能有多个 Shape 描述（来自不同 app 的注册）
+ * 数据在同一个位置，但可以用不同的 Shape 来解释
+ */
+export interface DataLocation {
+    /** 数据容器 URL - 唯一标识数据位置 */
+    container: string;
+    /** 主体 URI 模式 (可选) - deprecated, use subjectTemplate */
+    subjectPattern?: string;
+    /**
+     * @deprecated Legacy/explicit Subject URI template. Prefer exact base-relative ids.
+     */
+    subjectTemplate?: string;
+    /** 可用的 Shape 列表（按注册顺序） */
+    shapes: ShapeInfo[];
+    /** 发现来源（取第一个注册的来源） */
+    source: 'typeindex' | 'interop' | 'config';
+}
+/**
+ * 发现选项
+ */
+export interface DiscoverOptions {
+    /** 只查找自己注册的 */
+    selfOnly?: boolean;
+    /** 按应用 origin 过滤 */
+    origin?: string;
+    /** 按应用 ID 过滤 */
+    appId?: string;
+}
+/**
+ * locationToTable 转换选项
+ *
+ * 三种选择 Shape 的方式（按优先级）：
+ * 1. shape - 直接传入 ShapeInfo 对象或 Shape URL
+ * 2. appId - 选择该 app 注册的 Shape
+ * 3. 都不传 - 使用第一个可用的 Shape
+ */
+export interface LocationToTableOptions {
+    /** 直接指定 Shape（ShapeInfo 对象或 Shape URL 字符串） */
+    shape?: ShapeInfo | string;
+    /** 按 appId 选择该 app 注册的 Shape */
+    appId?: string;
+}
+/**
+ * 数据注册信息 - 包含完整的注册元数据
+ */
+export interface DataRegistrationInfo {
+    /** 注册资源的 URL */
+    registrationUrl: string;
+    /** 数据容器 URL */
+    container: string;
+    /** RDF 类型 */
+    rdfClass: string;
+    /** ShapeTree URL */
+    shapeTree: string;
+    /** Shape URL - 实际的 SHACL Shape 定义 */
+    shape?: string;
+    /**
+     * @deprecated Legacy/explicit Subject URI template. Prefer exact base-relative ids.
+     */
+    subjectTemplate?: string;
+    /** 注册此数据的应用/代理 */
+    registeredBy?: string;
+    /** 注册时间 */
+    registeredAt?: Date;
+}
+/**
+ * 数据发现接口
+ *
+ * 负责：
+ * 1. 注册表的类型到发现机制 (TypeIndex / Interop Registry)
+ * 2. 发现某类型数据的存储位置
+ * 3. 检查类型是否已注册
+ */
+export interface DataDiscovery {
+    /**
+     * 注册表的类型
+     * @param table PodTable 定义
+     * @param options 注册选项
+     */
+    register(table: PodTable, options?: RegisterOptions): Promise<void>;
+    /**
+     * 发现某类型数据的位置
+     * @param rdfClass RDF 类型 URI
+     * @param options 可选的过滤选项
+     */
+    discover(rdfClass: string, options?: DiscoverOptions): Promise<DataLocation[]>;
+    /**
+     * 检查类型是否已注册
+     * @param rdfClass RDF 类型 URI
+     */
+    isRegistered(rdfClass: string): Promise<boolean>;
+    /**
+     * 获取所有数据注册 (可选实现)
+     */
+    discoverAll?(): Promise<DataRegistrationInfo[]>;
+    /**
+     * 按应用 ID 发现数据位置 (可选实现)
+     * @param appId 应用标识符
+     */
+    discoverByApp?(appId: string): Promise<DataLocation[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/core/exact-records.d.ts

@@ -0,0 +1,21 @@
+import type { PodTable } from './schema';
+type ExactRecordTarget = string | Record<string, unknown> | null | undefined;
+type ExactRecordResolvedTarget = string | Record<string, unknown>;
+type ExactPodTable = PodTable<any>;
+export type ExactRecordDatabase = {
+    findByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget) => Promise<unknown | null>;
+    updateByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget, data: any) => Promise<unknown | null>;
+    deleteByResource?: <TResource extends ExactPodTable>(resource: TResource, target: ExactRecordResolvedTarget) => Promise<unknown>;
+    insert?: <TResource extends ExactPodTable>(resource: TResource) => {
+        values(value: any): {
+            execute(): Promise<unknown>;
+        };
+    };
+};
+export declare function findExactRecord<T>(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget): Promise<T | null>;
+export declare function updateExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, updates: Record<string, unknown>): Promise<void>;
+export declare function upsertExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, row: Record<string, unknown>, updates: Record<string, unknown>): Promise<'inserted' | 'updated'>;
+export declare function insertExactRecordOnce(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget, row: Record<string, unknown>): Promise<boolean>;
+export declare function deleteExactRecord(db: ExactRecordDatabase, resource: ExactPodTable, target: ExactRecordTarget): Promise<void>;
+export {};
+//# sourceMappingURL=exact-records.d.ts.map