@undefineds.co/xpod 0.4.18 → 0.4.19

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

@@ -0,0 +1,60 @@
+import { type DrizzleConfig } from 'drizzle-orm/utils';
+import { PodDatabase } from './core/pod-database';
+import { type SolidAuthSession, type PodDialectConfig } from './core/pod-dialect';
+import type { ChannelType } from './core/notifications';
+import type { SPARQLQueryEngineFactory } from './core/sparql-engine';
+export type SolidDatabase<TSchema extends Record<string, unknown> = Record<string, never>> = PodDatabase<TSchema>;
+export interface SolidDrizzleConfig<TSchema extends Record<string, unknown> = Record<string, never>> extends DrizzleConfig<TSchema> {
+    /**
+     * Schema registry used for URI/link resolution and typed query access.
+     * Drizzle's upstream `DrizzleConfig` typing does not currently expose this field
+     * on the imported utility type, so we declare it explicitly here.
+     */
+    schema?: TSchema;
+    /**
+     * Backward-compatible alias for legacy drizzle-solid callers.
+     * Prefer `debug`, but keep `logger` accepted to avoid needless breakage.
+     */
+    logger?: boolean;
+    /** Notifications 配置 */
+    notifications?: {
+        /** 通道偏好顺序，默认 ['streaming-http', 'websocket'] */
+        preferredChannels?: ChannelType[];
+    };
+    /** SPARQL 执行器配置 */
+    sparql?: {
+        /**
+         * 自定义 QueryEngine 工厂。
+         * 可用于复用宿主应用或 xpod 自身安装的 Comunica。
+         */
+        createQueryEngine?: SPARQLQueryEngineFactory;
+    };
+    /** Disable Solid Interop discovery (optional) */
+    disableInteropDiscovery?: boolean;
+    /**
+     * 是否自动连接到 Pod（默认 false，按需延迟连接）
+     */
+    autoConnect?: boolean;
+    /**
+     * Storage 缓存过期时间（毫秒），默认 5 分钟
+     * 用于 IdP-SP 分离场景，控制从 profile 重新读取 pim:storage 的频率
+     */
+    storageTTL?: number;
+    /** Explicit Pod base URL for IdP/SP split deployments. */
+    podUrl?: string;
+    /**
+     * Controls implicit LDP container/resource probes before ORM operations.
+     * Use `off` when the Pod runtime or sidecar owns path creation and direct writes
+     * should not be blocked by HEAD/container preparation probes.
+     */
+    resourcePreparation?: PodDialectConfig['resourcePreparation'];
+    /**
+     * 启用 debug 模式，输出查询信息
+     */
+    debug?: boolean;
+}
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(session: SolidAuthSession, config?: SolidDrizzleConfig<TSchema>): SolidDatabase<TSchema>;
+export type { PodDatabase };
+export { PodDatabase as Database };
+export type { SolidAuthSession };
+//# sourceMappingURL=driver.d.ts.map

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

@@ -0,0 +1,31 @@
+export { pod, PodClient, PodCollection, PodEntity, type PodCollectionQueryOptions } from './pod';
+export { drizzle, type SolidDatabase, type SolidAuthSession } from './driver';
+export * from './solid';
+export { findByIRI } from './utils/find-by-iri';
+export { resolveRowSubject } from './core/query-builders/helpers';
+export { deleteExactRecord, findExactRecord, insertExactRecordOnce, updateExactRecord, upsertExactRecord, type ExactRecordDatabase, } from './core/exact-records';
+export { buildPodResourceIri, buildPodResourceIriForDatabase, buildPodResourceIriForResource, parsePodResourceRef, extractPodResourceTemplateValue, normalizePodDataResourceId, resolvePodBaseUrl, resolvePodBaseUrlFromDatabase, resolvePodResourceIriForDatabase, resolvePodResourceId, resolvePodResourceTemplateValue, type PodResourceReference, type PodResourceTarget, } from './core/resource-reference';
+export { createRepositoryDescriptor, definePodRepository, initSolidResources, initSolidTables, type AnyPodResource, type AnyPodTable, type PodRepositoryDescriptor, type PodRepositoryOptions, type RepositoryCacheOptions, type RepositoryInvalidations, type RepositoryScope, } from './core/repository';
+export { podTable, alias, string, int, integer, boolean, date, json, object, uri, iri, text, varchar, char, timestamp, datetime, bigint, smallint, tinyint, mediumint, serial, real, decimal, numeric, float, double, jsonb, id, relations, solidSchema, SolidSchema, isSolidSchema, type PodColumnBase as PodColumn, type PodResource, type PodResourceWithColumns, type PodTable, type SolidSchemaOptions, type NamespaceConfig, type PodTableOptions, type PodTableMapping, type PodColumnMapping, type PodColumnOptions, type InferTableData, type InferInsertData, type InferUpdateData, type RelationDefinition, type RelationOptions, type DiscoverFunction, type HookContext, type TableHooks, type SolidSession, } from './core/schema';
+export { ProfileManager } from './core/profile-manager';
+export { configureSparqlEngine, createNodeModuleSparqlEngineFactory, type SPARQLEngineConfig, type SPARQLQueryEngine, type SPARQLQueryEngineFactory, } from './core/sparql-engine';
+export { SelectQueryBuilder, InsertQueryBuilder, UpdateQueryBuilder, DeleteQueryBuilder, renderDefaultIdTemplate, type DefaultIdTemplateOptions, } from './core/query-builders';
+export type { SelectFieldMap, InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from './core/query-builders/types';
+export { DrizzleShapeManager, XSD, SHACL, } from './core/shape';
+export type { ShapeManager, Shape, ShapeProperty, ValidationResult as ShapeValidationResult, ValidationError as ShapeValidationError } from './core/shape';
+export { ProviderCache, INTEROP, SHAPETREES, type DataDiscovery, type DataLocation, type ShapeInfo, type DiscoverOptions, type RegisterOptions, type DataRegistrationInfo, type LocationToTableOptions, type WellKnownResponse, } from './core/discovery';
+export { createThing, readThing, updateThing, deleteThing, batchThingOperations, type ThingData } from './utils/thing-operations';
+export { validateRDFData, parseRDFResponse, } from './utils/rdf-validation';
+export type { ValidationResult as RdfValidationResult, ParsedRDFData } from './utils/rdf-validation';
+export { extendNamespace } from './utils/namespace';
+export { parseRDFSchema, getPredicateTypeScriptType, validatePredicateType, findPredicateType, rdfTypeToTypeScript, type RDFSchemaDefinition, type SchemaParseResult } from './core/rdf-schema-parser';
+export type { TimeContext, ResourceMode, ParsedSubject, } from './core/uri';
+export { createTypedTable, field, CommonFields, typedTable, type TypedField, type TypedTableDefinition, type TypedTableResult } from './core/compile-time-types';
+export { createTableSchema, createInsertSchema, createUpdateSchema, TableSchemaBuilder, getTableSchema } from './core/zod-integration';
+export { eq, ne, gt, gte, lt, lte, like, ilike, between, notBetween, regex, inArray, notInArray, isNull, isNotNull, and, or, not, exists, notExists, conditions, type QueryCondition, type PublicQueryCondition, type PublicWhereInput, type PublicWhereObject, } from './core/query-conditions';
+export { asc, desc, type OrderByExpression } from './core/order-by';
+export { count, sum, avg, min, max, type AggregateExpression } from './core/aggregates';
+export { ConflictResolver, createConflictResolver, saveWithConflictResolution, type MergeStrategy, type ConflictResolutionConfig, type ConflictResolutionResult } from './core/conflict-resolution';
+export { NotificationsClient, type NotificationEvent, type NotificationType, type ChannelType, type SubscribeOptions, type TableSubscribeOptions, type EntitySubscribeOptions, type Subscription, type SubscriptionFeature } from './core/notifications';
+export { FederatedQueryExecutor, federatedQueryExecutor, type FederatedResult, type FederatedError, type FederatedQueryOptions, type DiscoveredLocation, type FederatedQueryContext } from './core/federated';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,140 @@
+import type { EntitySubscribeOptions, TableSubscribeOptions, Subscription } from './core/notifications';
+import type { OrderByExpression } from './core/order-by';
+import type { SelectFieldMap } from './core/pod-session';
+import type { PublicQueryCondition, PublicWhereObject } from './core/query-conditions';
+import { PodTable, SolidSchema, type InferInsertData, type InferTableData, type InstantiateTableOptions, type PodColumnBase } from './core/schema';
+import type { DataLocation, DiscoverOptions, LocationToTableOptions } from './core/discovery';
+import type { FederatedError } from './core/federated';
+import { type SolidAuthSession, type SolidDatabase, type SolidDrizzleConfig } from './driver';
+type CollectionWhere = PublicWhereObject | PublicQueryCondition;
+type CollectionOrderBy = PodColumnBase | string | OrderByExpression | 'asc' | 'desc';
+export interface PodCollectionQueryOptions<TTable extends PodTable<any> = PodTable<any>> {
+    fields?: SelectFieldMap;
+    where?: CollectionWhere;
+    limit?: number;
+    offset?: number;
+    orderBy?: CollectionOrderBy[];
+}
+export declare class PodEntity<TTable extends PodTable<any>, TSchema extends Record<string, unknown> = Record<string, never>> {
+    private readonly db;
+    readonly table: TTable;
+    readonly iri: string;
+    constructor(db: SolidDatabase<TSchema>, table: TTable, iri: string);
+    get documentUrl(): string;
+    get fragment(): string | null;
+    get(): Promise<InferTableData<TTable> | null>;
+    read(): Promise<InferTableData<TTable> | null>;
+    update(data: Partial<Omit<InferTableData<TTable>, '@id' | 'id'>>): Promise<InferTableData<TTable> | null>;
+    delete(): Promise<boolean>;
+    subscribe(options: EntitySubscribeOptions<InferTableData<TTable>>): Promise<() => void>;
+}
+export declare class PodCollection<TTable extends PodTable<any>, TSchema extends Record<string, unknown> = Record<string, never>> {
+    private readonly db;
+    readonly table: TTable;
+    constructor(db: SolidDatabase<TSchema>, table: TTable);
+    byIri(iri: string): PodEntity<TTable, TSchema>;
+    entity(iri: string): PodEntity<TTable, TSchema>;
+    iriFor(record: InferInsertData<TTable>): string;
+    select(fields?: SelectFieldMap): import("./core/pod-session").SelectQueryBuilder<TTable>;
+    list(options?: PodCollectionQueryOptions<TTable>): Promise<InferTableData<TTable>[]>;
+    first(options?: PodCollectionQueryOptions<TTable>): Promise<InferTableData<TTable> | null>;
+    create(record: InferInsertData<TTable>): Promise<InferTableData<TTable> | null>;
+    create(records: InferInsertData<TTable>[]): Promise<Array<InferTableData<TTable>>>;
+    createMany(records: InferInsertData<TTable>[]): Promise<Array<InferTableData<TTable>>>;
+    subscribe(options: TableSubscribeOptions): Promise<Subscription>;
+}
+export declare class PodClient<TSchema extends Record<string, unknown> = Record<string, never>> {
+    private readonly db;
+    constructor(db: SolidDatabase<TSchema>);
+    asDrizzle(): SolidDatabase<TSchema>;
+    get query(): { [K in keyof TSchema as TSchema[K] extends PodTable<any> ? K : never]: TSchema[K] extends PodTable<any> ? {
+        findMany<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(options?: {
+            where?: PublicWhereObject | PublicQueryCondition;
+            columns?: SelectFieldMap;
+            limit?: number;
+            offset?: number;
+            orderBy?: {
+                column: PodColumnBase | string | OrderByExpression;
+                direction?: "asc" | "desc";
+            }[] | {
+                column: PodColumnBase | string | OrderByExpression;
+                direction?: "asc" | "desc";
+            };
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T[]>;
+        findFirst<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(options?: {
+            where?: PublicWhereObject | PublicQueryCondition;
+            columns?: SelectFieldMap;
+            limit?: number;
+            offset?: number;
+            orderBy?: {
+                column: PodColumnBase | string | OrderByExpression;
+                direction?: "asc" | "desc";
+            }[] | {
+                column: PodColumnBase | string | OrderByExpression;
+                direction?: "asc" | "desc";
+            };
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T | null>;
+        find<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(target: string | {
+            [x: string]: unknown;
+        }, options?: {
+            columns?: SelectFieldMap;
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T | null>;
+        findById<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(id: string, options?: {
+            columns?: SelectFieldMap;
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T | null>;
+        findByResource<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(target: string | {
+            [x: string]: unknown;
+        }, options?: {
+            columns?: SelectFieldMap;
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T | null>;
+        findByLocator<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(locator: {
+            [x: string]: unknown;
+        }, options?: {
+            columns?: SelectFieldMap;
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T | null>;
+        findByIri<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(iri: string, options?: {
+            columns?: SelectFieldMap;
+            with?: Record<string, boolean | {
+                table?: PodTable<any>;
+            }>;
+        }): Promise<T | null>;
+        count(options?: {
+            where?: PublicWhereObject | PublicQueryCondition;
+        }): Promise<number>;
+    } : never; };
+    bind<TColumns extends Record<string, PodColumnBase<any, any, any, any>>>(schema: SolidSchema<TColumns>, options: InstantiateTableOptions): PodTable<TColumns>;
+    locationToTable(location: DataLocation, options?: LocationToTableOptions): Promise<PodTable<any>>;
+    discoverTablesFor(rdfClass: string, options?: DiscoverOptions, tableOptions?: LocationToTableOptions): Promise<PodTable<any>[]>;
+    collection<TTable extends PodTable<any>>(table: TTable): PodCollection<TTable, TSchema>;
+    entity<TTable extends PodTable<any>>(table: TTable, iri: string): PodEntity<TTable, TSchema>;
+    init<TTable extends PodTable<any>>(...tables: Array<TTable | TTable[]>): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sparql(query: string): Promise<unknown[]>;
+    batch<TOperations extends readonly unknown[]>(operations: TOperations): Promise<{
+        [K in keyof TOperations]: Awaited<TOperations[K]>;
+    }>;
+    getLastFederatedErrors(): FederatedError[];
+    get discovery(): import("./core/discovery").DataDiscovery;
+}
+export declare function pod<TSchema extends Record<string, unknown> = Record<string, never>>(session: SolidAuthSession, config?: SolidDrizzleConfig<TSchema>): PodClient<TSchema>;
+export {};
+//# sourceMappingURL=pod.d.ts.map

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

@@ -0,0 +1,21 @@
+export { drizzle, type SolidDatabase } from './driver';
+type SolidInlineSessionOptions = {
+    webId: string;
+    fetch: typeof fetch;
+    sessionId?: string;
+};
+type SolidInlineSessionInfo = {
+    isLoggedIn: boolean;
+    webId: string;
+    sessionId: string;
+};
+type SolidInlineSession = {
+    info: SolidInlineSessionInfo;
+    fetch: typeof fetch;
+    login: () => Promise<void>;
+    logout: () => Promise<void>;
+    handleIncomingRedirect: () => Promise<void>;
+};
+export declare const solid: (options: SolidInlineSessionOptions) => SolidInlineSession;
+export type { SolidInlineSession, SolidInlineSessionInfo, SolidInlineSessionOptions };
+//# sourceMappingURL=solid.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/test-utils/real-test-helpers.d.ts

@@ -0,0 +1,5 @@
+import { describe } from 'vitest';
+export declare const ENABLE_REAL_TESTS: boolean;
+export declare function describeIfReal(...args: Parameters<typeof describe>): ReturnType<typeof describe>;
+export declare function warnIfRealTestsSkipped(label: string): void;
+//# sourceMappingURL=real-test-helpers.d.ts.map

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

@@ -0,0 +1,27 @@
+export interface SPARQLQuery {
+    type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'CONSTRUCT' | 'ASK' | 'DESCRIBE' | 'UNKNOWN';
+    query: string;
+    prefixes?: Record<string, string>;
+}
+export interface SPARQLBinding {
+    [variable: string]: SPARQLTerm;
+}
+export interface SPARQLTerm {
+    type: 'uri' | 'literal' | 'bnode';
+    value: string;
+    datatype?: string;
+    'xml:lang'?: string;
+}
+export interface SPARQLResults {
+    head: {
+        vars: string[];
+    };
+    results: {
+        bindings: SPARQLBinding[];
+    };
+}
+export interface SPARQLUpdateResult {
+    success: boolean;
+    message?: string;
+}
+//# sourceMappingURL=sparql-types.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/find-by-iri.d.ts

@@ -0,0 +1,11 @@
+import { PodAsyncSession } from '../core/pod-session';
+import { PodDatabase } from '../core/pod-database';
+import { PodTable, type InferTableData } from '../core/schema';
+type GenericPodTable = PodTable<any>;
+/**
+ * 从绝对 IRI 或 fragment 查询单行记录。
+ * 支持传入 PodDatabase 或 PodAsyncSession。
+ */
+export declare function findByIRI<TTable extends GenericPodTable>(dbOrSession: PodDatabase | PodAsyncSession, table: TTable, iri: string): Promise<InferTableData<TTable> | null>;
+export {};
+//# sourceMappingURL=find-by-iri.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 防抖函数
+ */
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * 节流函数
+ */
+export declare function throttle<T extends (...args: unknown[]) => unknown>(func: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * 深拷贝对象
+ */
+export declare function deepClone<T>(obj: T): T;
+/**
+ * 格式化错误信息
+ */
+export declare function formatError(error: unknown): string;
+//# sourceMappingURL=helpers.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/namespace.d.ts

@@ -0,0 +1,4 @@
+export declare function extendNamespace<TBase extends Record<string, unknown>, TExtras extends Record<string, string>>(base: TBase, extras: TExtras, options?: {
+    namespace?: string;
+}): TBase & TExtras;
+//# sourceMappingURL=namespace.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/rdf-helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 验证 RDF 三元组格式
+ */
+export declare function validateTriple(triple: unknown): boolean;
+/**
+ * 生成唯一的资源 URI
+ */
+export declare function generateResourceUri(baseUri: string, resourceType: string, id?: string): string;
+/**
+ * 格式化错误信息
+ */
+export declare function formatError(error: unknown): string;
+/**
+ * 构建 SPARQL 查询字符串
+ */
+export declare function buildSparqlQuery(selectFields: string[], graphUri: string, conditions?: Record<string, unknown>): string;
+//# sourceMappingURL=rdf-helpers.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/rdf-validation.d.ts

@@ -0,0 +1,27 @@
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+type RDFObjectValue = string | number | boolean | Date | null;
+export interface RDFTriple {
+    subject: string;
+    predicate: string;
+    object: RDFObjectValue;
+}
+export interface ParsedRDFData {
+    triples: RDFTriple[];
+    subjects: Set<string>;
+    predicates: Set<string>;
+    objects: Set<RDFObjectValue>;
+}
+/**
+ * 验证 RDF 数据的有效性
+ */
+export declare function validateRDFData(data: unknown): ValidationResult;
+/**
+ * 解析 RDF 响应数据
+ */
+export declare function parseRDFResponse(response: string, format?: 'turtle' | 'jsonld' | 'ntriples'): ParsedRDFData;
+export {};
+//# sourceMappingURL=rdf-validation.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/thing-operations.d.ts

@@ -0,0 +1,28 @@
+export interface ThingData {
+    [key: string]: string | number | Date | string[] | undefined;
+}
+/**
+ * 创建一个新的 Thing
+ */
+export declare function createThing(containerUrl: string, thingUrl: string, data: ThingData, fetchFn?: typeof fetch): Promise<string>;
+/**
+ * 读取一个 Thing
+ */
+export declare function readThing(resourceUrl: string, thingUrl: string, fetchFn?: typeof fetch): Promise<ThingData | null>;
+/**
+ * 更新一个 Thing
+ */
+export declare function updateThing(resourceUrl: string, thingUrl: string, data: ThingData, fetchFn?: typeof fetch): Promise<boolean>;
+/**
+ * 删除一个 Thing
+ */
+export declare function deleteThing(resourceUrl: string, thingUrl: string, fetchFn?: typeof fetch): Promise<boolean>;
+/**
+ * 批量操作 Things
+ */
+export declare function batchThingOperations(resourceUrl: string, operations: Array<{
+    type: 'create' | 'update' | 'delete';
+    thingUrl: string;
+    data?: ThingData;
+}>, fetchFn?: typeof fetch): Promise<boolean>;
+//# sourceMappingURL=thing-operations.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/dist/esm/utils/webid-resolver.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Resolver to find the actual storage root (SP) from a WebID (IdP).
+ * Implements the IdP-SP Separation architecture.
+ */
+export declare class WebIdResolver {
+    private cache;
+    private extractStorageFromProfile;
+    /**
+     * Resolve the storage root URL from a WebID Profile.
+     * Prioritizes pim:storage (WSIM) over solid:pod.
+     *
+     * @param webId The WebID to resolve
+     * @param fetchFn The authenticated fetch function (optional)
+     * @returns The resolved storage URL (with trailing slash), or null if not found
+     */
+    resolveStorage(webId: string, fetchFn?: typeof fetch): Promise<string | null>;
+    /**
+     * Clear the internal cache
+     */
+    clearCache(): void;
+}
+export declare const webIdResolver: WebIdResolver;
+//# sourceMappingURL=webid-resolver.d.ts.map

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/index.ts

@@ -0,0 +1,4 @@
+import * as z from "./v4/classic/external.js";
+export * from "./v4/classic/external.js";
+export { z };
+export default z;

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/locales/index.ts

@@ -0,0 +1 @@
+export * from "../v4/locales/index.js";

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/mini/index.ts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };