@svadmin/core 0.58.0 → 0.60.0

package/README.md

@@ -3,7 +3,7 @@
 Use the existing `useForm.validate` callback with a shared TypeBox schema:
 
 ```ts
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { createSchemaFormValidator, useForm } from '@svadmin/core';
 
 const Input = Type.Object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "author": "zuohuadong",
   "repository": {
     "type": "git",
@@ -135,7 +135,7 @@
   "dependencies": {
     "@types/papaparse": "^5.5.2",
     "@internationalized/date": "^3.12.3",
-    "@sinclair/typebox": "^0.34.52",
+    "typebox": "^1.3.34",
     "papaparse": "^5.5.4"
   },
   "peerDependenciesMeta": {

package/src/access-control-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { HttpError } from './types';

package/src/admin-tool.ts

@@ -1,5 +1,5 @@
-import type { StaticDecode, TObject } from '@sinclair/typebox';
-import { Value } from '@sinclair/typebox/value';
+import type { StaticDecode, TObject } from 'typebox';
+import { Value } from 'typebox/value';
 
 /** Result returned by a tool execution. */
 export interface ToolResult {
@@ -61,7 +61,10 @@ export function decodeAdminToolArgs<const Schema extends TObject>(
   tool: AdminTool<Schema>,
   input: unknown,
 ): StaticDecode<Schema> {
-  return Value.Decode(strictAdminToolSchema(tool.parameters), input);
+  const schema = strictAdminToolSchema(tool.parameters);
+  // TypeBox 1.x Value.Decode strips undeclared properties instead of rejecting them.
+  if (!Value.Check(schema, input)) throw new Error('Admin tool arguments do not match the declared schema');
+  return Value.Decode(schema, input);
 }
 
 /** Decodes and executes a tool without allowing callers to bypass runtime input validation. */
@@ -94,6 +97,9 @@ export function projectAdminToolSchema<Schema extends TObject>(tool: AdminTool<S
 }
 
 function strictAdminToolSchema<Schema extends TObject>(schema: Schema): Schema {
-  if (schema.additionalProperties === false) return schema;
-  return { ...schema, additionalProperties: false };
+  if ((schema as { additionalProperties?: unknown }).additionalProperties === false) return schema;
+  // Spreading would drop TypeBox 1.x non-enumerable markers such as ~codec; clone instead.
+  const copy = Value.Clone(schema) as TObject & { additionalProperties?: boolean };
+  copy.additionalProperties = false;
+  return copy as Schema;
 }

package/src/approval-contract.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import type { EnterpriseProviderRequestContext } from './enterprise';

package/src/audit-contract.ts

@@ -1,4 +1,4 @@
-import { Type, type Static, type TSchema } from '@sinclair/typebox';
+import { Type, ObjectOptions, type Static, type TSchema } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 
@@ -27,8 +27,8 @@ const entrySchema = Type.Object({
   userAgent: Type.Optional(text),
   error: Type.Optional(Type.Object({ message: Type.String(), code: Type.Optional(text) }, { additionalProperties: false })),
 }, { additionalProperties: false });
-const draftSchema = Type.Omit(entrySchema, ['id', 'timestamp']);
-const createSchema = Type.Omit(entrySchema, ['id']);
+const draftSchema = Type.Omit(entrySchema, ['id', 'timestamp'], ObjectOptions(entrySchema));
+const createSchema = Type.Omit(entrySchema, ['id'], ObjectOptions(entrySchema));
 const querySchema = Type.Object({
   resource: Type.Optional(text), action: Type.Optional(text),
   meta: Type.Optional(record), author: Type.Optional(record),

package/src/audit.ts

@@ -1,5 +1,5 @@
 import { definedOptions } from './defined-options';
-import { Value } from '@sinclair/typebox/value';
+import { Value } from 'typebox/value';
 import {
   AuditError, createAuditEntry, decodeAuditCreate, decodeAuditEntries, decodeAuditEntry, decodeAuditQuery,
   type AuditCreateParams, type AuditDraft, type AuditEntry, type AuditQueryParams,

package/src/auth-mutation-contract.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import type { AuthProvider } from './types';
 import { authErrorSchema, authRedirectSchema, decodeIdentity } from './auth-query-contract';
 import { snapshotPlainData } from './plain-data';

package/src/auth-query-contract.ts

@@ -1,4 +1,4 @@
-import { Type, type Static, type TSchema } from '@sinclair/typebox';
+import { Type, type Static, type TSchema } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 

package/src/command-contract.ts

@@ -1,5 +1,4 @@
-import { Type, type TObject, type TSchema } from '@sinclair/typebox';
-import { TypeGuard } from '@sinclair/typebox/type';
+import { Type, type TObject, type TSchema } from 'typebox';
 import { checkExact } from './schema-validation';
 import { closeContractSchema, type SafeSchema, type SchemaValue } from './resource-contract';
 import { snapshotPlainData } from './plain-data';
@@ -101,7 +100,7 @@ export function defineCommand(name: string, definition: {
     const outputSchema: unknown = fields['output']?.value;
     if (typeof url !== 'string' || !url.trim() ||
         (method !== 'get' && method !== 'post' && method !== 'put' && method !== 'patch' && method !== 'delete') ||
-        !TypeGuard.IsObject(inputSchema) || !TypeGuard.IsSchema(outputSchema)) {
+        !Type.IsObject(inputSchema) || !Type.IsSchema(outputSchema)) {
       return invalidContract();
     }
     const input = closeContractSchema(inputSchema);

package/src/contract-form.svelte.ts

@@ -16,7 +16,7 @@ import { invalidateOwnedQueries } from './query-invalidation';
 import { appendListQueryFromPath } from './url-sync';
 import { HttpError } from './types';
 import { useTranslation } from './i18n.svelte';
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { auditWithProvider } from './audit';
 import { fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';

package/src/create-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { definedOptions } from './defined-options';

package/src/create-many-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 import { parseContractId, parseContractRecord, parseContractCreateInput, requireContractCreateSchema,

package/src/dashboard-contract.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import type { EnterpriseProviderRequestContext } from './enterprise';

package/src/delete-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 import { HttpError } from './types';

package/src/delete-many-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 import { parseContractId, parseContractRecord, parseContractDeleteInput, type ContractSchemas, type ContractId, type ResourceContract } from './resource-contract';

package/src/export-format.ts

@@ -1,7 +1,7 @@
 // Pure export formatting helpers with no Svelte rune or browser API dependencies except downloadData.
 // These helpers can be tested directly with bun:test.
 
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 

package/src/feature-gate-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { HttpError } from './types';

package/src/helpers-pure.ts

@@ -2,6 +2,7 @@
 // Extracted to enable unit testing with bun test
 
 import type { Filter, Sort, CrudOperator } from './types';
+import { schemaIssues } from './schema-validation';
 
 // ─── Table Helpers ────────────────────────────────────────────
 
@@ -168,21 +169,24 @@ export function parseCSV(text: string): string[][] {
 // ─── TypeBox Validator Helper ───────────────────────────────────
 
 /**
- * TypeBox validator interface matching TypeCompiler.Compile or Value.Errors
+ * TypeBox validator interface matching Compile or Value.Errors
  */
 export type TypeBoxValidatorLike = {
   Check?: (value: unknown) => boolean;
-  Errors: (value: unknown) => Iterable<{ path?: string; message: string }>;
+  Errors: (value: unknown) => Iterable<{
+    path?: string; instancePath?: string; keyword?: string;
+    params?: Record<string, unknown>; message: string;
+  }>;
 };
 
 /**
  * Creates a synchronous form validator function specifically optimized for TypeBox
- * compiled validators (from TypeCompiler.Compile) or TypeBox value checks.
+ * compiled validators (from Compile) or TypeBox value checks.
  *
  * @example
  * ```ts
- * import { Type } from '@sinclair/typebox';
- * import { TypeCompiler } from '@sinclair/typebox/compiler';
+ * import { Type } from 'typebox';
+ * import { Compile } from 'typebox/compile';
  * import { createTypeBoxValidator, useForm } from '@svadmin/core';
  *
  * const userSchema = Type.Object({
@@ -190,7 +194,7 @@ export type TypeBoxValidatorLike = {
  *   email: Type.String({ format: 'email' }),
  * });
  *
- * const compiledUser = TypeCompiler.Compile(userSchema);
+ * const compiledUser = Compile(userSchema);
  *
  * const form = useForm({
  *   resource: 'users',
@@ -205,10 +209,10 @@ export function createTypeBoxValidator(
     if (validator.Check?.(values)) return null;
 
     const errors: Record<string, string> = {};
-    for (const error of validator.Errors(values)) {
-      const path = (error.path ?? '').replace(/^\//, '').replace(/\//g, '.');
+    for (const issue of schemaIssues(validator.Errors(values))) {
+      const path = issue.path.replace(/^\//, '').replace(/\//g, '.');
       const key = path || '_root';
-      if (!errors[key]) errors[key] = error.message;
+      if (!errors[key]) errors[key] = issue.message;
     }
 
     return Object.keys(errors).length > 0 ? errors : null;

package/src/http.ts

@@ -3,8 +3,8 @@
  */
 
 import { HttpError,type ValidationErrors } from './types';
-import { Type } from '@sinclair/typebox';
-import { Value } from '@sinclair/typebox/value';
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
 import { definedOptions } from './defined-options';
 
 export interface FetchWithInterceptorOptions {

package/src/import-contract.ts

@@ -1,5 +1,5 @@
 import Papa from 'papaparse';
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { HttpError } from './types';

package/src/index.ts

@@ -304,7 +304,7 @@ export {
   generateComponentCode,
   generateResourceBundle,
 } from './inferencer';
-export type { InferResult } from './inferencer';
+export type { InferResult, InferReview, InferReviewWarning, InferReviewWarningCode } from './inferencer';
 export { createWebSocketLiveProvider } from './live-websocket';
 export type { WebSocketLiveProviderOptions } from './live-websocket';
 export { createSSELiveProvider } from './live-sse';

package/src/inferencer.ts

@@ -84,6 +84,7 @@ export interface InferResult {
   resource: ResourceDefinition;
   code: string;
   typeboxCode: string;
+  review: InferReview;
   componentCode: {
     list: string;
     create: string;
@@ -92,6 +93,26 @@ export interface InferResult {
   };
 }
 
+export type InferReviewWarningCode =
+  | 'empty-sample'
+  | 'nullable-field'
+  | 'mixed-types'
+  | 'heuristic-relation'
+  | 'heuristic-select';
+
+export interface InferReviewWarning {
+  code: InferReviewWarningCode;
+  field?: string;
+  message: string;
+}
+
+export interface InferReview {
+  needsReview: boolean;
+  confidence: 'high' | 'medium' | 'low';
+  sampleSize: number;
+  warnings: InferReviewWarning[];
+}
+
 /**
  * Analyze a sample data array and produce a ResourceDefinition.
  * @param resourceName - Name of the resource (e.g. "posts")
@@ -116,6 +137,15 @@ export function inferResource(
       resource: emptyResource,
       code: `// No data available to infer fields for "${resourceName}".`,
       typeboxCode: generateTypeBoxSchemaCode(emptyResource),
+      review: {
+        needsReview: true,
+        confidence: 'low',
+        sampleSize: 0,
+        warnings: [{
+          code: 'empty-sample',
+          message: `No sample records were available for "${resourceName}".`,
+        }],
+      },
       componentCode: {
         list: generateListPageCode(emptyResource),
         create: generateCreatePageCode(emptyResource),
@@ -133,6 +163,7 @@ export function inferResource(
 
   // For each key, infer from all non-null values
   const fields: FieldDefinition[] = [];
+  const warnings: InferReviewWarning[] = [];
   for (const key of keySet) {
     // Collect non-null values
     const values = sampleData
@@ -141,6 +172,13 @@ export function inferResource(
 
     const sampleValue = values[0];
     let inferredType = inferFieldType(key, sampleValue);
+    if (values.length === 0) {
+      warnings.push({
+        code: 'nullable-field',
+        field: key,
+        message: `Field "${key}" contains only null or undefined values in the sample.`,
+      });
+    }
 
     // Cross-validate: if most values for this key are of a different type, use majority
     const typeCounts = new Map<InferredType, number>();
@@ -155,13 +193,34 @@ export function inferResource(
         inferredType = t;
       }
     }
+    if (typeCounts.size > 1) {
+      warnings.push({
+        code: 'mixed-types',
+        field: key,
+        message: `Field "${key}" contains multiple inferred types; the majority type was selected.`,
+      });
+    }
 
     // Check for relation
     const relatedResource = isLikelyRelation(key);
+    if (relatedResource) {
+      warnings.push({
+        code: 'heuristic-relation',
+        field: key,
+        message: `Relation "${key}" was inferred from its field name.`,
+      });
+    }
 
     // Check if it looks like a select (few unique string values)
     const uniqueStrings = new Set(values.filter(v => typeof v === 'string') as string[]);
     const isSelect = inferredType === 'text' && uniqueStrings.size > 1 && uniqueStrings.size <= 10 && values.length >= 5;
+    if (isSelect) {
+      warnings.push({
+        code: 'heuristic-select',
+        field: key,
+        message: `Select options for "${key}" were inferred from repeated sample values.`,
+      });
+    }
 
     const field: FieldDefinition = {
       key,
@@ -213,7 +272,23 @@ export function inferResource(
     show: generateShowPageCode(resource),
   };
 
-  return { fields, resource, code, typeboxCode, componentCode };
+  return {
+    fields,
+    resource,
+    code,
+    typeboxCode,
+    review: {
+      needsReview: warnings.length > 0,
+      confidence: warnings.some((warning) => warning.code === 'mixed-types' || warning.code === 'nullable-field')
+        ? 'low'
+        : warnings.length > 0
+          ? 'medium'
+          : 'high',
+      sampleSize: sampleData.length,
+      warnings,
+    },
+    componentCode,
+  };
 }
 
 // ─── Code Generation ─────────────────────────────────────────
@@ -407,7 +482,7 @@ export function generateTypeBoxSchemaCode(resource: ResourceDefinition): string
   const baseName = resource.name.endsWith('s') ? resource.name.slice(0, -1) : resource.name;
   const typeName = capitalize(baseName);
 
-  return `import { Type, type Static } from '@sinclair/typebox';
+  return `import { Type, type Static } from 'typebox';
 
 export const ${typeName}Schema = Type.Object({
 ${schemaProps}
@@ -462,6 +537,12 @@ export function generateResourceBundle(resource: ResourceDefinition): InferResul
     resource,
     code: generateResourceCode(resource),
     typeboxCode: generateTypeBoxSchemaCode(resource),
+    review: {
+      needsReview: false,
+      confidence: 'high',
+      sampleSize: 0,
+      warnings: [],
+    },
     componentCode: {
       list: generateListPageCode(resource),
       create: generateCreatePageCode(resource),

package/src/infinite-query.svelte.ts

@@ -1,7 +1,7 @@
 import { createInfiniteQuery, type InfiniteData, type InfiniteQueryObserverBaseResult, type QueryObserverResult,
   type RefetchOptions, type FetchNextPageOptions, type FetchPreviousPageOptions } from '@tanstack/svelte-query';
 import { tick } from 'svelte';
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { definedOptions } from './defined-options';
 import { getAdminOptions } from './options.svelte';
 import { useParsed } from './useParsed.svelte';

package/src/invalidation-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 import { HttpError } from './types';

package/src/live-sse.ts

@@ -1,6 +1,6 @@
 import type { LiveProvider } from './live.svelte';
 import { createLiveSubscribers, decodeLiveMessage, notifyLiveObserver, readLiveOptions, captureLiveObserver } from './live-transport';
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 

package/src/live-subscription.svelte.ts

@@ -1,6 +1,6 @@
 import { untrack } from 'svelte';
 import type { QueryClient } from '@tanstack/svelte-query';
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { captureAdminContext } from './context.svelte';
 import { contractKey, type ResourceContract } from './resource-contract';
 import { captureQueryProvider } from './query-snapshot';

package/src/live-transport.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData, type JsonValue } from './plain-data';
 import { definedOptions } from './defined-options';

package/src/permission-catalog.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import type { AccessControlOptions, AccessControlProvider, CanParams } from './permissions.svelte';

package/src/permission-hints-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { decodePermissionSnapshot, permissionSnapshotSchema, type PermissionSnapshot } from './permission-catalog';

package/src/query-invalidation.ts

@@ -4,7 +4,7 @@ import { snapshotPlainData } from './plain-data';
 import { snapshotInvalidationParams } from './invalidation-contract';
 import { definedOptions } from './defined-options';
 import { HttpError } from './types';
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 
 export interface QueryCacheOwner {

package/src/query-keys.ts

@@ -1,4 +1,4 @@
-import { Type,type Static } from '@sinclair/typebox';
+import { Type,type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { definedOptions } from './defined-options';
 import { snapshotPlainData, type JsonValue } from './plain-data';

package/src/query-session.svelte.ts

@@ -1,6 +1,6 @@
 import { hashKey, useQueryClient, type QueryObserverPendingResult, type QueryObserverResult, type RefetchOptions } from '@tanstack/svelte-query';
 import { untrack } from 'svelte';
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import type { AdminContextAccessor } from './context.svelte';
 import { captureAuthLiveScope, clearAuthQueries, handleAuthError } from './auth-hooks.svelte';
 import { decodeBaseRecord } from './record-decoder';

package/src/query-snapshot.ts

@@ -1,4 +1,4 @@
-import { Type, type Static, type TSchema } from '@sinclair/typebox';
+import { Type, type Static, type TSchema } from 'typebox';
 import type { AdminContextAccessor } from './context.svelte';
 import type { DataProvider, GetListParams, GetOneParams, GetManyParams } from './types';
 import { HttpError } from './types';
@@ -8,20 +8,22 @@ import { attachAbortSignal, detachAbortSignal, snapshotPlainData } from './plain
 import { checkExact } from './schema-validation';
 import { decodeBaseRecord, decodeListResult, decodeOneResult, decodeManyResult, rejectProviderResponse } from './record-decoder';
 
-const filters = Type.Recursive(self => Type.Union([
-  Type.Object({
-    field: Type.String(),
-    operator: Type.Union(([
-      'eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'in', 'nin', 'contains', 'ncontains',
-      'startswith', 'endswith', 'null', 'nnull', 'between', 'nbetween',
-    ] as const).map(value => Type.Literal(value))),
-    value: Type.Unknown(),
-  }, { additionalProperties: false }),
-  Type.Object({
-    operator: Type.Union([Type.Literal('and'), Type.Literal('or')]),
-    value: Type.Array(self),
-  }, { additionalProperties: false }),
-]));
+const filters = Type.Cyclic({
+  Filters: Type.Union([
+    Type.Object({
+      field: Type.String(),
+      operator: Type.Union(([
+        'eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'in', 'nin', 'contains', 'ncontains',
+        'startswith', 'endswith', 'null', 'nnull', 'between', 'nbetween',
+      ] as const).map(value => Type.Literal(value))),
+      value: Type.Unknown(),
+    }, { additionalProperties: false }),
+    Type.Object({
+      operator: Type.Union([Type.Literal('and'), Type.Literal('or')]),
+      value: Type.Array(Type.Ref('Filters')),
+    }, { additionalProperties: false }),
+  ]),
+}, 'Filters');
 const base = {
   resource: Type.String({ minLength: 1 }),
   meta: Type.Optional(Type.Record(Type.String(), Type.Unknown())),

package/src/record-decoder.ts

@@ -1,11 +1,22 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { createExactSchemaValidator } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { HttpError, type BaseRecord, type GetListResult, type GetOneResult, type GetManyResult, type CustomResult } from './types';
 
 export type RecordDecoder<T extends BaseRecord> = (value: unknown) => T;
 
-const record = Type.Record(Type.String(), Type.Unknown());
+/** TypeBox 1.x Record validation accepts class instances; keep records limited to plain JSON objects. */
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const prototype: unknown = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+const record = Type.Refine(
+  Type.Record(Type.String(), Type.Unknown()),
+  isPlainRecord,
+  () => 'Expected plain object',
+);
 const recordValidator = createExactSchemaValidator(record);
 const customValidator = createExactSchemaValidator(Type.Object({ data: Type.Unknown() }));
 const oneValidator = createExactSchemaValidator(Type.Object({ data: record }));

package/src/resource-contract.ts

@@ -1,6 +1,6 @@
-import { CloneType, Kind, TransformKind, Type, type Static, type TObject, type TSchema } from '@sinclair/typebox';
-import { checkExact, createExactSchemaValidator } from './schema-validation';
-import { TypeGuard } from '@sinclair/typebox/type';
+import { Type, type Static, type TObject, type TSchema } from 'typebox';
+import { Value } from 'typebox/value';
+import { checkExact, createExactSchemaValidator, schemaIssues } from './schema-validation';
 import { DeleteManyPartialError, HttpError, type DataProvider, type KnownResources, type BaseRecord,
   type GetListResult, type GetManyParams, type CreateManyParams, type UpdateManyParams, type DeleteManyParams,
   type GetOneParams, type GetOneResult, type GetManyResult } from './types';
@@ -70,26 +70,33 @@ interface Definition {
 const definitions = new WeakMap<ResourceContract, Definition>();
 let nextKey = 0;
 
+/** TypeBox 1.x stores the schema kind under the non-enumerable `~kind` marker instead of a symbol. */
+function schemaKind(schema: TSchema): string | undefined {
+  const kind = (schema as { '~kind'?: unknown })['~kind'];
+  return typeof kind === 'string' ? kind : undefined;
+}
+
 // A deliberately closed JSON subset keeps runtime validation aligned with Static.
 export function closeContractSchema<S extends TSchema>(schema: S): S {
-  const copy = CloneType(schema);
+  const copy = Value.Clone(schema);
   const visit = (node: TSchema): void => {
-    if (TransformKind in node) {
+    if ('~codec' in node) {
       throw new HttpError('Contract transforms require a separate decoding boundary', 400, undefined, { code: 'INVALID_RESOURCE_CONTRACT' });
     }
-    if (!TypeGuard.IsSchema(node) || !['Object', 'Array', 'Tuple', 'Union', 'String', 'Number', 'Integer', 'Boolean', 'Null', 'Literal', 'Never'].includes(node[Kind])) {
+    if (!Type.IsSchema(node) || !['Object', 'Array', 'Tuple', 'Union', 'String', 'Number', 'Integer', 'Boolean', 'Null', 'Literal', 'Never'].includes(schemaKind(node) ?? '')) {
       throw new HttpError('Unsupported or unconstrained contract schema', 400, undefined, { code: 'INVALID_RESOURCE_CONTRACT' });
     }
-    if (TypeGuard.IsObject(node)) {
-      if (node.additionalProperties !== undefined && node.additionalProperties !== false) {
+    if (Type.IsObject(node)) {
+      const objectNode = node as TSchema & { additionalProperties?: TSchema | boolean };
+      if (objectNode.additionalProperties !== undefined && objectNode.additionalProperties !== false) {
         throw new HttpError('Contract objects must be closed', 400, undefined, { code: 'INVALID_RESOURCE_CONTRACT' });
       }
-      node.additionalProperties = false;
+      objectNode.additionalProperties = false;
       for (const property of Object.values(node.properties)) visit(property);
     }
-    if (TypeGuard.IsArray(node)) visit(node.items);
-    if (TypeGuard.IsTuple(node)) for (const item of node.items ?? []) visit(item);
-    if (TypeGuard.IsUnion(node)) for (const item of node.anyOf) visit(item);
+    if (Type.IsArray(node)) visit(node.items);
+    if (Type.IsTuple(node)) for (const item of node.items ?? []) visit(item);
+    if (Type.IsUnion(node)) for (const item of node.anyOf) visit(item);
   };
   visit(copy);
   return copy;
@@ -101,11 +108,11 @@ export function defineResource<const S extends ContractSchemas>(
 ): ResourceContract<S>;
 export function defineResource(name: KnownResources, schemas: ContractSchemas): ResourceContract {
   const isId = (schema: TSchema): boolean => (
-    ['String', 'Number', 'Integer'].includes(schema[Kind])
-    || (TypeGuard.IsLiteral(schema) && ['string', 'number'].includes(typeof schema.const))
-    || (TypeGuard.IsUnion(schema) && schema.anyOf.every(isId))
+    ['String', 'Number', 'Integer'].includes(schemaKind(schema) ?? '')
+    || (Type.IsLiteral(schema) && ['string', 'number'].includes(typeof schema.const))
+    || (Type.IsUnion(schema) && schema.anyOf.every(isId))
   );
-  if (!name.trim() || schemas.record[Kind] !== 'Object'
+  if (!name.trim() || schemaKind(schemas.record) !== 'Object'
     || !schemas.record.required?.includes('id')
     || !schemas.record.properties['id']
     || !isId(schemas.record.properties['id'])) {
@@ -177,7 +184,7 @@ export interface ContractProjectionOptions {
 }
 
 function projectBySchema(schema: TSchema, value: unknown): unknown {
-  if (TypeGuard.IsObject(schema)) {
+  if (Type.IsObject(schema)) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) return value;
     const source = value as Record<string, unknown>;
     const projected: Record<string, unknown> = {};
@@ -186,15 +193,15 @@ function projectBySchema(schema: TSchema, value: unknown): unknown {
     }
     return projected;
   }
-  if (TypeGuard.IsArray(schema)) {
+  if (Type.IsArray(schema)) {
     return Array.isArray(value) ? value.map(item => projectBySchema(schema.items, item)) : value;
   }
-  if (TypeGuard.IsTuple(schema)) {
+  if (Type.IsTuple(schema)) {
     return Array.isArray(value)
       ? value.map((item, index) => schema.items?.[index] ? projectBySchema(schema.items[index], item) : item)
       : value;
   }
-  if (TypeGuard.IsUnion(schema)) {
+  if (Type.IsUnion(schema)) {
     const branch = schema.anyOf.find(candidate => checkExact(candidate, value));
     return branch ? projectBySchema(branch, value) : value;
   }
@@ -394,7 +401,7 @@ export function parseContractDeleteInput(contract: ResourceContract, value: unkn
 export function contractFormValues(contract: ResourceContract, action: string, value: Record<string, unknown>): Record<string, unknown> {
   const schemas = definitionOf(contract).schemas;
   const schema = action === 'edit' ? schemas.update : schemas.create;
-  if (!schema || !TypeGuard.IsObject(schema)) {
+  if (!schema || !Type.IsObject(schema)) {
     throw new HttpError('Forms require an object input schema for their action', 400, undefined, { code: 'INVALID_RESOURCE_CONTRACT' });
   }
   const projected = Object.fromEntries(Object.keys(schema.properties)
@@ -406,7 +413,7 @@ export function contractFormValues(contract: ResourceContract, action: string, v
 function formSchema(contract: ResourceContract, action: ContractFormAction): TObject {
   const schemas = definitionOf(contract).schemas;
   const schema = action === 'show' ? schemas.record : action === 'edit' ? schemas.update : schemas.create;
-  if (!schema || !TypeGuard.IsObject(schema)) {
+  if (!schema || !Type.IsObject(schema)) {
     throw new HttpError('Forms require an object schema for their action', 400, undefined, { code: 'INVALID_RESOURCE_CONTRACT' });
   }
   return schema;
@@ -445,7 +452,7 @@ export function snapshotContractFormDraft(contract: ResourceContract, action: Co
 export function contractFormInvalidFields(contract: ResourceContract, action: ContractFormAction, value: unknown): string[] {
   const schema = formSchema(contract, action);
   const validator = createExactSchemaValidator(schema);
-  const paths = Array.from(validator.Errors(value), error => error.path);
+  const paths = schemaIssues(validator.Errors(value)).map(issue => issue.path);
   const fields = Object.keys(schema.properties).filter(field => {
     const path = `/${field.replaceAll('~', '~0').replaceAll('/', '~1')}`;
     return paths.some(candidate => candidate === path || candidate.startsWith(`${path}/`));
@@ -460,7 +467,7 @@ export function parseContractFormInput<S extends ContractSchemas, A extends 'cre
 export function parseContractFormInput(contract: ResourceContract, action: 'create' | 'edit', value: unknown): BaseRecord {
   const schemas = definitionOf(contract).schemas;
   const schema = action === 'edit' ? schemas.update : schemas.create;
-  if (!schema || !TypeGuard.IsObject(schema)) {
+  if (!schema || !Type.IsObject(schema)) {
     throw new HttpError('Forms require an object input schema for their action', 400, undefined, { code: 'INVALID_RESOURCE_CONTRACT' });
   }
   check(schema, value, 'values');

package/src/resource-schemas.ts

@@ -1,5 +1,5 @@
-import { Type, type Static, type TSchema } from '@sinclair/typebox';
-import { checkExact, createExactSchemaValidator } from './schema-validation';
+import { Type, type Static, type TSchema } from 'typebox';
+import { checkExact, createExactSchemaValidator, schemaIssues } from './schema-validation';
 import { attachAbortSignal, detachAbortSignal, snapshotPlainData } from './plain-data';
 import { decodeBaseRecord, decodeOneResult, decodeManyResult, decodeListResult } from './record-decoder';
 import { HttpError } from './types';
@@ -43,22 +43,24 @@ const common = {
   resource: Type.String({ minLength: 1 }),
   meta: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 };
-const filter = Type.Recursive(Self => Type.Union([
-  Type.Object({
-    operator: Type.Union([Type.Literal('or'), Type.Literal('and')]),
-    value: Type.Array(Self),
-  }, { additionalProperties: false }),
-  Type.Object({
-    field: Type.String(),
-    operator: Type.Union([
-      Type.Literal('eq'), Type.Literal('ne'), Type.Literal('lt'), Type.Literal('gt'),
-      Type.Literal('lte'), Type.Literal('gte'), Type.Literal('contains'), Type.Literal('ncontains'),
-      Type.Literal('startswith'), Type.Literal('endswith'), Type.Literal('in'), Type.Literal('nin'),
-      Type.Literal('null'), Type.Literal('nnull'), Type.Literal('between'), Type.Literal('nbetween'),
-    ]),
-    value: Type.Unknown(),
-  }, { additionalProperties: false }),
-]));
+const filter = Type.Cyclic({
+  Filter: Type.Union([
+    Type.Object({
+      operator: Type.Union([Type.Literal('or'), Type.Literal('and')]),
+      value: Type.Array(Type.Ref('Filter')),
+    }, { additionalProperties: false }),
+    Type.Object({
+      field: Type.String(),
+      operator: Type.Union([
+        Type.Literal('eq'), Type.Literal('ne'), Type.Literal('lt'), Type.Literal('gt'),
+        Type.Literal('lte'), Type.Literal('gte'), Type.Literal('contains'), Type.Literal('ncontains'),
+        Type.Literal('startswith'), Type.Literal('endswith'), Type.Literal('in'), Type.Literal('nin'),
+        Type.Literal('null'), Type.Literal('nnull'), Type.Literal('between'), Type.Literal('nbetween'),
+      ]),
+      value: Type.Unknown(),
+    }, { additionalProperties: false }),
+  ]),
+}, 'Filter');
 const requestSchemas = {
   getList: Type.Object({
     ...common,
@@ -166,8 +168,7 @@ function createSchemaBoundary(schemas: ResourceSchemaMap) {
       }
       if (validator.Check(value)) return;
       // Do not include rejected values or raw responses in diagnostic details.
-      issues = [...validator.Errors(value)]
-        .map(({ path, message }) => ({ path, message }));
+      issues = schemaIssues(validator.Errors(value));
     } catch {
       throw new HttpError('Unable to evaluate resource schema', 500, undefined, {
         code: 'RESOURCE_SCHEMA_INVALID',

package/src/resource-transport-config.ts

@@ -1,5 +1,4 @@
-import { Hint, Kind, OptionalKind, ReadonlyKind, type TSchema } from '@sinclair/typebox';
-import { TypeGuard } from '@sinclair/typebox/type';
+import { Type, type TSchema } from 'typebox';
 import { HttpError } from './types';
 import type { DataProvider } from './types';
 import type { ResourceSchemas } from './resource-schemas';
@@ -15,6 +14,9 @@ function invalidProvider(): never {
   });
 }
 
+/** Scalar TypeBox 1.x markers that may be carried through a configuration snapshot. */
+const TYPEBOX_MARKERS = new Set(['~kind', '~optional', '~readonly', '~immutable']);
+
 /** Configuration can carry TypeBox markers, but no getters, functions or foreign symbols. */
 function copySchemaData(value: unknown, ancestors = new Set<object>(), depth = 0): unknown {
   if (depth > 128) return invalidSchema();
@@ -41,11 +43,18 @@ function copySchemaData(value: unknown, ancestors = new Set<object>(), depth = 0
     }
     const copy: Record<PropertyKey, unknown> = {};
     for (const key of Reflect.ownKeys(descriptors)) {
-      if (typeof key === 'symbol' && key !== Kind && key !== OptionalKind && key !== ReadonlyKind && key !== Hint) {
-        return invalidSchema();
+      // TypeBox 1.x marks schema metadata with non-enumerable `~`-prefixed string keys.
+      if (typeof key === 'symbol') return invalidSchema();
+      if (key.startsWith('~')) {
+        if (!TYPEBOX_MARKERS.has(key)) return invalidSchema();
+        const marker: PropertyDescriptor | undefined = Reflect.get(descriptors, key);
+        if (!marker || !('value' in marker) || marker.get || marker.set) return invalidSchema();
+        const markerValue: unknown = marker.value;
+        if (typeof markerValue !== 'string' && typeof markerValue !== 'boolean') return invalidSchema();
+        Object.defineProperty(copy, key, { value: markerValue, enumerable: false, configurable: true, writable: false });
+        continue;
       }
       const field = read(key);
-      if (typeof key === 'symbol' && typeof field !== 'string') return invalidSchema();
       Object.defineProperty(copy, key, { value: field, enumerable: true, configurable: true, writable: true });
     }
     return copy;
@@ -56,7 +65,7 @@ function copySchemaData(value: unknown, ancestors = new Set<object>(), depth = 0
 
 function schema(value: unknown): TSchema {
   const copy = copySchemaData(value);
-  if (!TypeGuard.IsSchema(copy)) return invalidSchema();
+  if (!Type.IsSchema(copy) || typeof (copy as { '~kind'?: unknown })['~kind'] !== 'string') return invalidSchema();
   return copy;
 }
 
@@ -88,7 +97,7 @@ export function captureResourceSchemas(value: unknown): Map<string, ResourceSche
         if (!Array.isArray(copied)) return invalidSchema();
         const candidates: unknown[] = copied;
         for (const candidate of candidates) {
-          if (!TypeGuard.IsSchema(candidate)) return invalidSchema();
+          if (!Type.IsSchema(candidate)) return invalidSchema();
           references.push(candidate);
         }
       }

package/src/schema-form.ts

@@ -1,5 +1,5 @@
-import { Type, type TSchema } from '@sinclair/typebox';
-import { Value } from '@sinclair/typebox/value';
+import { Type, type TSchema } from 'typebox';
+import { Value } from 'typebox/value';
 
 export type SchemaFormScalar = string | number | boolean | null;
 

package/src/schema-validation.ts

@@ -1,17 +1,39 @@
-import { CloneType, TransformKind, Type, type Static, type TSchema } from '@sinclair/typebox';
-import { TypeGuard } from '@sinclair/typebox/type';
-import { Value } from '@sinclair/typebox/value';
+import { Type, type Static, type TSchema } from 'typebox';
+import { Value } from 'typebox/value';
+
+const CODEC_KEY = '~codec';
+
+/** JSON Schema keywords that TypeBox 1.x stores but does not expose on every typed interface. */
+interface SchemaMeta {
+  $id?: string;
+  $defs?: Record<string, TSchema>;
+  properties?: Record<string, TSchema>;
+  required?: readonly string[];
+  additionalProperties?: TSchema | boolean;
+  patternProperties?: Record<string, TSchema>;
+  contains?: TSchema;
+  unevaluatedProperties?: TSchema | boolean;
+  anyOf?: TSchema[];
+  allOf?: TSchema[];
+  items?: TSchema | TSchema[];
+  not?: TSchema;
+}
 
 /**
  * Strengthen optional-property presence with ordinary schemas, without changing
  * TypeBox's process-wide policy or maintaining a second value validator.
  */
-function exactSchema(schema: TSchema): TSchema {
-  if (TypeGuard.IsObject(schema)) {
+function exactSchema(input: TSchema): TSchema {
+  const schema = input as TSchema & SchemaMeta;
+  if (typeof schema.not === 'object' && Type.IsSchema(schema.not)) {
+    schema.not = exactSchema(schema.not);
+  }
+  if (Type.IsObject(input)) {
+    const properties = schema.properties ?? {};
     schema.properties = Object.fromEntries(
-      Object.entries(schema.properties).map(([key, property]) => [key, exactSchema(property)]),
+      Object.entries(properties).map(([key, property]) => [key, exactSchema(property)]),
     );
-    if (TypeGuard.IsSchema(schema.additionalProperties)) {
+    if (typeof schema.additionalProperties === 'object' && Type.IsSchema(schema.additionalProperties)) {
       schema.additionalProperties = exactSchema(schema.additionalProperties);
     }
     const optional = Object.entries(schema.properties)
@@ -20,7 +42,8 @@ function exactSchema(schema: TSchema): TSchema {
 
     const constraints = optional.map(([key, property]) => Type.Union([
       Type.Required(Type.Object({ [key]: property })),
-      Type.Not(Type.Object({ [key]: Type.Unknown() })),
+      // TypeBox 1.x removed Type.Not; the JSON Schema `not` keyword is expressed through Unsafe.
+      Type.Unsafe({ not: Type.Object({ [key]: Type.Unknown() }) }),
     ]));
     // The presence constraint owns each optional value's validation. Leaving it
     // in both places would validate deep optional objects exponentially often.
@@ -28,57 +51,117 @@ function exactSchema(schema: TSchema): TSchema {
     // References must resolve to the strengthened object, not its inner copy.
     const id = schema.$id;
     delete schema.$id;
-    const transform = Object.getOwnPropertyDescriptor(schema, TransformKind);
-    Reflect.deleteProperty(schema, TransformKind);
+    const codec = Object.getOwnPropertyDescriptor(schema, CODEC_KEY);
+    Reflect.deleteProperty(schema, CODEC_KEY);
     const result = Type.Intersect([schema, ...constraints], id === undefined ? {} : { $id: id });
-    if (transform !== undefined) Object.defineProperty(result, TransformKind, transform);
+    if (codec !== undefined) Object.defineProperty(result, CODEC_KEY, codec);
     return result;
   }
-  if (TypeGuard.IsArray(schema)) {
-    schema.items = exactSchema(schema.items);
-    if (TypeGuard.IsSchema(schema.contains)) schema.contains = exactSchema(schema.contains);
-  } else if (TypeGuard.IsTuple(schema)) {
-    if (schema.items) schema.items = schema.items.map(exactSchema);
-  } else if (TypeGuard.IsUnion(schema)) {
-    schema.anyOf = schema.anyOf.map(exactSchema);
-  } else if (TypeGuard.IsIntersect(schema)) {
-    schema.allOf = schema.allOf.map(exactSchema);
-    if (TypeGuard.IsSchema(schema.unevaluatedProperties)) {
+  if (Type.IsArray(input)) {
+    schema.items = exactSchema(schema.items as TSchema);
+    if (typeof schema.contains === 'object' && Type.IsSchema(schema.contains)) {
+      schema.contains = exactSchema(schema.contains);
+    }
+  } else if (Type.IsTuple(input)) {
+    if (Array.isArray(schema.items)) schema.items = schema.items.map(exactSchema);
+  } else if (Type.IsUnion(input)) {
+    schema.anyOf = (schema.anyOf ?? []).map(exactSchema);
+  } else if (Type.IsIntersect(input)) {
+    schema.allOf = (schema.allOf ?? []).map(exactSchema);
+    if (typeof schema.unevaluatedProperties === 'object' && Type.IsSchema(schema.unevaluatedProperties)) {
       schema.unevaluatedProperties = exactSchema(schema.unevaluatedProperties);
     }
-  } else if (TypeGuard.IsNot(schema)) {
-    schema.not = exactSchema(schema.not);
-  } else if (TypeGuard.IsRecord(schema)) {
+  } else if (Type.IsRecord(input)) {
     schema.patternProperties = Object.fromEntries(
-      Object.entries(schema.patternProperties).map(([key, property]) => [key, exactSchema(property)]),
+      Object.entries(schema.patternProperties ?? {}).map(([key, property]) => [key, exactSchema(property)]),
     );
-    if (TypeGuard.IsSchema(schema.additionalProperties)) {
+    if (typeof schema.additionalProperties === 'object' && Type.IsSchema(schema.additionalProperties)) {
       schema.additionalProperties = exactSchema(schema.additionalProperties);
     }
-  } else if (TypeGuard.IsImport(schema)) {
+  } else if (Type.IsCyclic(input)) {
     schema.$defs = Object.fromEntries(
-      Object.entries(schema.$defs).map(([key, definition]) => {
-        if (!TypeGuard.IsSchema(definition)) throw new TypeError('Invalid imported schema definition');
-        return [key, exactSchema(definition)];
-      }),
+      Object.entries(schema.$defs ?? {}).map(([key, definition]) => [key, exactSchema(definition)]),
     );
   }
   return schema;
 }
 
+/** TypeBox 1.x resolves references through a Context keyed by Ref name instead of a `references` array. */
+function referenceContext(references: readonly TSchema[]): Record<string, TSchema> {
+  const context: Record<string, TSchema> = {};
+  for (const reference of references) {
+    const id = (reference as SchemaMeta).$id;
+    if (typeof id === 'string' && id.length > 0) context[id] = reference;
+  }
+  return context;
+}
+
 export function createExactSchemaValidator<S extends TSchema>(schema: S, references: readonly TSchema[] = []) {
-  const checked = exactSchema(CloneType(schema));
-  const checkedReferences = references.map(reference => exactSchema(CloneType(reference)));
+  const checked = exactSchema(Value.Clone(schema));
+  const checkedReferences = references.map(reference => exactSchema(Value.Clone(reference)));
+  const context = referenceContext(checkedReferences);
+  const hasReferences = Object.keys(context).length > 0;
   return {
     Check(value: unknown): value is Static<S> {
-      return Value.Check(checked, checkedReferences, value);
+      return hasReferences
+        ? Value.Check(context, checked, value)
+        : Value.Check(checked, value);
     },
     Errors(value: unknown) {
-      return Value.Errors(checked, checkedReferences, value);
+      return hasReferences
+        ? Value.Errors(context, checked, value)
+        : Value.Errors(checked, value);
     },
   };
 }
 
+/** One normalized validation issue with a field-scoped JSON Pointer. */
+export interface SchemaIssue {
+  path: string;
+  message: string;
+}
+
+interface SchemaErrorLike {
+  instancePath?: string;
+  path?: string;
+  keyword?: string;
+  params?: Record<string, unknown>;
+  message: string;
+}
+
+function escapePointerSegment(segment: string): string {
+  return segment.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+
+/**
+ * TypeBox 1.x reports Ajv-style errors that group missing properties into a single
+ * `required` issue. Normalize every error back into one field-scoped issue so callers
+ * can keep mapping messages onto individual form fields.
+ */
+export function schemaIssues(errors: Iterable<SchemaErrorLike>): SchemaIssue[] {
+  const issues: SchemaIssue[] = [];
+  for (const error of errors) {
+    const base = error.instancePath ?? error.path ?? '';
+    const required = error.params?.['requiredProperties'];
+    if (error.keyword === 'required' && Array.isArray(required)) {
+      for (const property of required) {
+        if (typeof property !== 'string') continue;
+        issues.push({
+          path: `${base}/${escapePointerSegment(property)}`,
+          message: `must have required property '${property}'`,
+        });
+      }
+      continue;
+    }
+    const additional = error.params?.['additionalProperty'];
+    issues.push({
+      path: typeof additional === 'string' ? `${base}/${escapePointerSegment(additional)}` : base,
+      message: error.message,
+    });
+  }
+  return issues;
+}
+
 const validators = new WeakMap<TSchema, ReturnType<typeof createExactSchemaValidator>>();
 
 /** Schemas are snapshotted on first use; later edits cannot weaken a live boundary. */
@@ -89,4 +172,4 @@ export function checkExact<S extends TSchema>(schema: S, value: unknown): value
     validators.set(schema, validator);
   }
   return validator.Check(value);
-}
+}

package/src/spreadsheet-workbook.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 

package/src/strict-command-hooks.svelte.ts

@@ -1,4 +1,4 @@
-import type { TObject, TSchema } from '@sinclair/typebox';
+import type { TObject, TSchema } from 'typebox';
 import { hashKey, useQueryClient } from '@tanstack/svelte-query';
 import { captureAdminContext, type AdminContextAccessor } from './context.svelte';
 import { commandDefinition, prepareCommand, parseCommandInput, parseCommandResponse,

package/src/task-contract.ts

@@ -1,4 +1,4 @@
-import { Type, type Static } from '@sinclair/typebox';
+import { Type, type Static } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 

package/src/task-provider.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { checkExact } from './schema-validation';
 import { snapshotPlainData } from './plain-data';
 import { TaskError, decodeTaskList, decodeTaskRecord, decodeTaskSubmitOptions, type SubmitTaskOptions } from './task-contract';

package/src/update-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 import { HttpError } from './types';

package/src/update-many-contract.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { snapshotPlainData } from './plain-data';
 import { checkExact } from './schema-validation';
 import { parseContractId, parseContractRecord, parseContractUpdateInput,

package/src/useStepsForm.svelte.ts

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 import { useContractForm, type ContractFormOptions } from './contract-form.svelte';
 import { getContractFormFields, type ContractSchemas, type ContractFormValues } from './resource-contract';
 import { snapshotPlainData } from './plain-data';