lookatstudy-mobile 0.33.2 → 0.34.0

package/server.cjs

@@ -6312,9 +6312,9 @@ var init_table = __esm({
       [IsDrizzleTable] = true;
       /** @internal */
       [ExtraConfigBuilder] = void 0;
-      constructor(name19, schema31, baseName) {
+      constructor(name19, schema32, baseName) {
         this[TableName] = this[OriginalName] = name19;
-        this[Schema] = schema31;
+        this[Schema] = schema32;
         this[BaseName] = baseName;
       }
     };
@@ -7378,7 +7378,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str2)]);
       }
       sql2.raw = raw;
-      function join15(chunks, separator) {
+      function join16(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -7388,7 +7388,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join15;
+      sql2.join = join16;
       function identifier(value) {
         return new Name(value);
       }
@@ -7437,11 +7437,11 @@ var init_sql = __esm({
       [ViewBaseConfig];
       /** @internal */
       [IsDrizzleView] = true;
-      constructor({ name: name26, schema: schema31, selectedFields, query: query2 }) {
+      constructor({ name: name26, schema: schema32, selectedFields, query: query2 }) {
         this[ViewBaseConfig] = {
           name: name26,
           originalName: name26,
-          schema: schema31,
+          schema: schema32,
           selectedFields,
           query: query2,
           isExisting: !query2,
@@ -7912,14 +7912,14 @@ function getOrderByOperators() {
     desc
   };
 }
-function extractTablesRelationalConfig(schema31, configHelpers) {
-  if (Object.keys(schema31).length === 1 && "default" in schema31 && !is(schema31["default"], Table)) {
-    schema31 = schema31["default"];
+function extractTablesRelationalConfig(schema32, configHelpers) {
+  if (Object.keys(schema32).length === 1 && "default" in schema32 && !is(schema32["default"], Table)) {
+    schema32 = schema32["default"];
   }
   const tableNamesMap = {};
   const relationsBuffer = {};
   const tablesConfig = {};
-  for (const [key2, value] of Object.entries(schema31)) {
+  for (const [key2, value] of Object.entries(schema32)) {
     if (is(value, Table)) {
       const dbName = getTableUniqueName(value);
       const bufferedRelations = relationsBuffer[dbName];
@@ -8001,7 +8001,7 @@ function createMany(sourceTable) {
     return new Many(sourceTable, referencedTable, config2);
   };
 }
-function normalizeRelation(schema31, tableNamesMap, relation) {
+function normalizeRelation(schema32, tableNamesMap, relation) {
   if (is(relation, One) && relation.config) {
     return {
       fields: relation.config.fields,
@@ -8014,7 +8014,7 @@ function normalizeRelation(schema31, tableNamesMap, relation) {
       `Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`
     );
   }
-  const referencedTableConfig = schema31[referencedTableTsName];
+  const referencedTableConfig = schema32[referencedTableTsName];
   if (!referencedTableConfig) {
     throw new Error(`Table "${referencedTableTsName}" not found in schema`);
   }
@@ -9028,8 +9028,8 @@ var init_all = __esm({
 });
 
 // node_modules/drizzle-orm/sqlite-core/table.js
-function sqliteTableBase(name19, columns, extraConfig, schema31, baseName = name19) {
-  const rawTable = new SQLiteTable(name19, schema31, baseName);
+function sqliteTableBase(name19, columns, extraConfig, schema32, baseName = name19) {
+  const rawTable = new SQLiteTable(name19, schema32, baseName);
   const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
   const builtColumns = Object.fromEntries(
     Object.entries(parsedColumns).map(([name26, colBuilderBase]) => {
@@ -9373,18 +9373,18 @@ var init_casing = __esm({
       getColumnCasing(column) {
         if (!column.keyAsName)
           return column.name;
-        const schema31 = column.table[Table.Symbol.Schema] ?? "public";
+        const schema32 = column.table[Table.Symbol.Schema] ?? "public";
         const tableName = column.table[Table.Symbol.OriginalName];
-        const key2 = `${schema31}.${tableName}.${column.name}`;
+        const key2 = `${schema32}.${tableName}.${column.name}`;
         if (!this.cache[key2]) {
           this.cacheTable(column.table);
         }
         return this.cache[key2];
       }
       cacheTable(table) {
-        const schema31 = table[Table.Symbol.Schema] ?? "public";
+        const schema32 = table[Table.Symbol.Schema] ?? "public";
         const tableName = table[Table.Symbol.OriginalName];
-        const tableKey = `${schema31}.${tableName}`;
+        const tableKey = `${schema32}.${tableName}`;
         if (!this.cachedTables[tableKey]) {
           for (const column of Object.values(table[Table.Symbol.Columns])) {
             const columnKey = `${tableKey}.${column.name}`;
@@ -9960,7 +9960,7 @@ var init_dialect = __esm({
       }
       buildRelationalQuery({
         fullSchema,
-        schema: schema31,
+        schema: schema32,
         tableNamesMap,
         table,
         tableConfig,
@@ -10068,7 +10068,7 @@ var init_dialect = __esm({
             relation
           } of selectedRelations) {
             const normalizedRelation = normalizeRelation(
-              schema31,
+              schema32,
               tableNamesMap,
               relation
             );
@@ -10088,10 +10088,10 @@ var init_dialect = __esm({
             );
             const builtRelation = this.buildRelationalQuery({
               fullSchema,
-              schema: schema31,
+              schema: schema32,
               tableNamesMap,
               table: fullSchema[relationTableTsName],
-              tableConfig: schema31[relationTableTsName],
+              tableConfig: schema32[relationTableTsName],
               queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
               tableAlias: relationTableAlias,
               joinOn: joinOn2,
@@ -10399,7 +10399,7 @@ var init_select2 = __esm({
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table))
             this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join15) => join15.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join16) => join16.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -11288,7 +11288,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join15) => join15.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join16) => join16.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -11491,10 +11491,10 @@ var init_query = __esm({
     init_query_promise();
     init_relations();
     RelationalQueryBuilder = class {
-      constructor(mode, fullSchema, schema31, tableNamesMap, table, tableConfig, dialect, session) {
+      constructor(mode, fullSchema, schema32, tableNamesMap, table, tableConfig, dialect, session) {
         this.mode = mode;
         this.fullSchema = fullSchema;
-        this.schema = schema31;
+        this.schema = schema32;
         this.tableNamesMap = tableNamesMap;
         this.table = table;
         this.tableConfig = tableConfig;
@@ -11550,10 +11550,10 @@ var init_query = __esm({
       }
     };
     SQLiteRelationalQuery = class extends QueryPromise {
-      constructor(fullSchema, schema31, tableNamesMap, table, tableConfig, dialect, session, config2, mode) {
+      constructor(fullSchema, schema32, tableNamesMap, table, tableConfig, dialect, session, config2, mode) {
         super();
         this.fullSchema = fullSchema;
-        this.schema = schema31;
+        this.schema = schema32;
         this.tableNamesMap = tableNamesMap;
         this.table = table;
         this.tableConfig = tableConfig;
@@ -11683,14 +11683,14 @@ var init_db = __esm({
     init_query();
     init_raw();
     BaseSQLiteDatabase = class {
-      constructor(resultKind, dialect, session, schema31) {
+      constructor(resultKind, dialect, session, schema32) {
         this.resultKind = resultKind;
         this.dialect = dialect;
         this.session = session;
-        this._ = schema31 ? {
-          schema: schema31.schema,
-          fullSchema: schema31.fullSchema,
-          tableNamesMap: schema31.tableNamesMap
+        this._ = schema32 ? {
+          schema: schema32.schema,
+          fullSchema: schema32.fullSchema,
+          tableNamesMap: schema32.tableNamesMap
         } : {
           schema: void 0,
           fullSchema: {},
@@ -11702,10 +11702,10 @@ var init_db = __esm({
           for (const [tableName, columns] of Object.entries(this._.schema)) {
             query2[tableName] = new RelationalQueryBuilder(
               resultKind,
-              schema31.fullSchema,
+              schema32.fullSchema,
               this._.schema,
               this._.tableNamesMap,
-              schema31.fullSchema[tableName],
+              schema32.fullSchema[tableName],
               columns,
               dialect,
               session
@@ -12206,9 +12206,9 @@ var init_session = __esm({
       }
     };
     SQLiteTransaction = class extends BaseSQLiteDatabase {
-      constructor(resultType, dialect, session, schema31, nestedIndex = 0) {
-        super(resultType, dialect, session, schema31);
-        this.schema = schema31;
+      constructor(resultType, dialect, session, schema32, nestedIndex = 0) {
+        super(resultType, dialect, session, schema32);
+        this.schema = schema32;
         this.nestedIndex = nestedIndex;
       }
       static [entityKind] = "SQLiteTransaction";
@@ -12369,10 +12369,10 @@ var init_session2 = __esm({
     init_session();
     init_utils();
     SQLJsSession = class extends SQLiteSession {
-      constructor(client, dialect, schema31, options = {}) {
+      constructor(client, dialect, schema32, options = {}) {
         super(dialect);
         this.client = client;
-        this.schema = schema31;
+        this.schema = schema32;
         this.logger = options.logger ?? new NoopLogger();
       }
       static [entityKind] = "SQLJsSession";
@@ -12496,20 +12496,20 @@ function drizzle(client, config2 = {}) {
   } else if (config2.logger !== false) {
     logger = config2.logger;
   }
-  let schema31;
+  let schema32;
   if (config2.schema) {
     const tablesConfig = extractTablesRelationalConfig(
       config2.schema,
       createTableRelationsHelpers
     );
-    schema31 = {
+    schema32 = {
       fullSchema: config2.schema,
       schema: tablesConfig.tables,
       tableNamesMap: tablesConfig.tableNamesMap
     };
   }
-  const session = new SQLJsSession(client, dialect, schema31, { logger });
-  return new BaseSQLiteDatabase("sync", dialect, session, schema31);
+  const session = new SQLJsSession(client, dialect, schema32, { logger });
+  return new BaseSQLiteDatabase("sync", dialect, session, schema32);
 }
 var init_driver = __esm({
   "node_modules/drizzle-orm/sql-js/driver.js"() {
@@ -15115,9 +15115,9 @@ function optionalKeys(shape) {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
   });
 }
-function pick(schema31, mask) {
+function pick(schema32, mask) {
   const newShape = {};
-  const currDef = schema31._zod.def;
+  const currDef = schema32._zod.def;
   for (const key2 in mask) {
     if (!(key2 in currDef.shape)) {
       throw new Error(`Unrecognized key: "${key2}"`);
@@ -15126,15 +15126,15 @@ function pick(schema31, mask) {
       continue;
     newShape[key2] = currDef.shape[key2];
   }
-  return clone(schema31, {
-    ...schema31._zod.def,
+  return clone(schema32, {
+    ...schema32._zod.def,
     shape: newShape,
     checks: []
   });
 }
-function omit(schema31, mask) {
-  const newShape = { ...schema31._zod.def.shape };
-  const currDef = schema31._zod.def;
+function omit(schema32, mask) {
+  const newShape = { ...schema32._zod.def.shape };
+  const currDef = schema32._zod.def;
   for (const key2 in mask) {
     if (!(key2 in currDef.shape)) {
       throw new Error(`Unrecognized key: "${key2}"`);
@@ -15143,27 +15143,27 @@ function omit(schema31, mask) {
       continue;
     delete newShape[key2];
   }
-  return clone(schema31, {
-    ...schema31._zod.def,
+  return clone(schema32, {
+    ...schema32._zod.def,
     shape: newShape,
     checks: []
   });
 }
-function extend(schema31, shape) {
+function extend(schema32, shape) {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const def = {
-    ...schema31._zod.def,
+    ...schema32._zod.def,
     get shape() {
-      const _shape = { ...schema31._zod.def.shape, ...shape };
+      const _shape = { ...schema32._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape);
       return _shape;
     },
     checks: []
     // delete existing checks
   };
-  return clone(schema31, def);
+  return clone(schema32, def);
 }
 function merge(a, b) {
   return clone(a, {
@@ -15178,8 +15178,8 @@ function merge(a, b) {
     // delete existing checks
   });
 }
-function partial(Class2, schema31, mask) {
-  const oldShape = schema31._zod.def.shape;
+function partial(Class2, schema32, mask) {
+  const oldShape = schema32._zod.def.shape;
   const shape = { ...oldShape };
   if (mask) {
     for (const key2 in mask) {
@@ -15201,14 +15201,14 @@ function partial(Class2, schema31, mask) {
       }) : oldShape[key2];
     }
   }
-  return clone(schema31, {
-    ...schema31._zod.def,
+  return clone(schema32, {
+    ...schema32._zod.def,
     shape,
     checks: []
   });
 }
-function required(Class2, schema31, mask) {
-  const oldShape = schema31._zod.def.shape;
+function required(Class2, schema32, mask) {
+  const oldShape = schema32._zod.def.shape;
   const shape = { ...oldShape };
   if (mask) {
     for (const key2 in mask) {
@@ -15230,8 +15230,8 @@ function required(Class2, schema31, mask) {
       });
     }
   }
-  return clone(schema31, {
-    ...schema31._zod.def,
+  return clone(schema32, {
+    ...schema32._zod.def,
     shape,
     // optional: [],
     checks: []
@@ -15543,9 +15543,9 @@ var init_parse = __esm({
     init_core();
     init_errors2();
     init_util();
-    _parse = (_Err) => (schema31, value, _ctx, _params) => {
+    _parse = (_Err) => (schema32, value, _ctx, _params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
-      const result = schema31._zod.run({ value, issues: [] }, ctx);
+      const result = schema32._zod.run({ value, issues: [] }, ctx);
       if (result instanceof Promise) {
         throw new $ZodAsyncError();
       }
@@ -15557,9 +15557,9 @@ var init_parse = __esm({
       return result.value;
     };
     parse = /* @__PURE__ */ _parse($ZodRealError);
-    _parseAsync = (_Err) => async (schema31, value, _ctx, params) => {
+    _parseAsync = (_Err) => async (schema32, value, _ctx, params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-      let result = schema31._zod.run({ value, issues: [] }, ctx);
+      let result = schema32._zod.run({ value, issues: [] }, ctx);
       if (result instanceof Promise)
         result = await result;
       if (result.issues.length) {
@@ -15570,9 +15570,9 @@ var init_parse = __esm({
       return result.value;
     };
     parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
-    _safeParse = (_Err) => (schema31, value, _ctx) => {
+    _safeParse = (_Err) => (schema32, value, _ctx) => {
       const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-      const result = schema31._zod.run({ value, issues: [] }, ctx);
+      const result = schema32._zod.run({ value, issues: [] }, ctx);
       if (result instanceof Promise) {
         throw new $ZodAsyncError();
       }
@@ -15582,9 +15582,9 @@ var init_parse = __esm({
       } : { success: true, data: result.value };
     };
     safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-    _safeParseAsync = (_Err) => async (schema31, value, _ctx) => {
+    _safeParseAsync = (_Err) => async (schema32, value, _ctx) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
-      let result = schema31._zod.run({ value, issues: [] }, ctx);
+      let result = schema32._zod.run({ value, issues: [] }, ctx);
       if (result instanceof Promise)
         result = await result;
       return result.issues.length ? {
@@ -23000,14 +23000,14 @@ var init_registries = __esm({
         this._map = /* @__PURE__ */ new Map();
         this._idmap = /* @__PURE__ */ new Map();
       }
-      add(schema31, ..._meta) {
+      add(schema32, ..._meta) {
         const meta = _meta[0];
-        this._map.set(schema31, meta);
+        this._map.set(schema32, meta);
         if (meta && typeof meta === "object" && "id" in meta) {
           if (this._idmap.has(meta.id)) {
             throw new Error(`ID ${meta.id} already exists in the registry`);
           }
-          this._idmap.set(meta.id, schema31);
+          this._idmap.set(meta.id, schema32);
         }
         return this;
       }
@@ -23016,25 +23016,25 @@ var init_registries = __esm({
         this._idmap = /* @__PURE__ */ new Map();
         return this;
       }
-      remove(schema31) {
-        const meta = this._map.get(schema31);
+      remove(schema32) {
+        const meta = this._map.get(schema32);
         if (meta && typeof meta === "object" && "id" in meta) {
           this._idmap.delete(meta.id);
         }
-        this._map.delete(schema31);
+        this._map.delete(schema32);
         return this;
       }
-      get(schema31) {
-        const p = schema31._zod.parent;
+      get(schema32) {
+        const p = schema32._zod.parent;
         if (p) {
           const pm = { ...this.get(p) ?? {} };
           delete pm.id;
-          return { ...pm, ...this._map.get(schema31) };
+          return { ...pm, ...this._map.get(schema32) };
         }
-        return this._map.get(schema31);
+        return this._map.get(schema32);
       }
-      has(schema31) {
-        return this._map.has(schema31);
+      has(schema32) {
+        return this._map.has(schema32);
       }
     };
     globalRegistry = /* @__PURE__ */ registry();
@@ -23595,11 +23595,11 @@ function _endsWith(suffix, params) {
     suffix
   });
 }
-function _property(property, schema31, params) {
+function _property(property, schema32, params) {
   return new $ZodCheckProperty({
     check: "property",
     property,
-    schema: schema31,
+    schema: schema32,
     ...normalizeParams(params)
   });
 }
@@ -23804,22 +23804,22 @@ function _promise(Class2, innerType) {
 function _custom(Class2, fn, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
-  const schema31 = new Class2({
+  const schema32 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...norm
   });
-  return schema31;
+  return schema32;
 }
 function _refine(Class2, fn, _params) {
-  const schema31 = new Class2({
+  const schema32 = new Class2({
     type: "custom",
     check: "custom",
     fn,
     ...normalizeParams(_params)
   });
-  return schema31;
+  return schema32;
 }
 function _stringbool(Classes2, _params) {
   const params = normalizeParams(_params);
@@ -23992,8 +23992,8 @@ function toJSONSchema(input, _params) {
     const gen2 = new JSONSchemaGenerator(_params);
     const defs = {};
     for (const entry of input._idmap.entries()) {
-      const [_, schema31] = entry;
-      gen2.process(schema31);
+      const [_, schema32] = entry;
+      gen2.process(schema32);
     }
     const schemas = {};
     const external = {
@@ -24002,8 +24002,8 @@ function toJSONSchema(input, _params) {
       defs
     };
     for (const entry of input._idmap.entries()) {
-      const [key2, schema31] = entry;
-      schemas[key2] = gen2.emit(schema31, {
+      const [key2, schema32] = entry;
+      schemas[key2] = gen2.emit(schema32, {
         ..._params,
         external
       });
@@ -24025,8 +24025,8 @@ function isTransforming(_schema, _ctx) {
   if (ctx.seen.has(_schema))
     return false;
   ctx.seen.add(_schema);
-  const schema31 = _schema;
-  const def = schema31._zod.def;
+  const schema32 = _schema;
+  const def = schema32._zod.def;
   switch (def.type) {
     case "string":
     case "number":
@@ -24134,9 +24134,9 @@ var init_to_json_schema = __esm({
         this.io = params?.io ?? "output";
         this.seen = /* @__PURE__ */ new Map();
       }
-      process(schema31, _params = { path: [], schemaPath: [] }) {
+      process(schema32, _params = { path: [], schemaPath: [] }) {
         var _a27;
-        const def = schema31._zod.def;
+        const def = schema32._zod.def;
         const formatMap = {
           guid: "uuid",
           url: "uri",
@@ -24145,27 +24145,27 @@ var init_to_json_schema = __esm({
           regex: ""
           // do not set
         };
-        const seen = this.seen.get(schema31);
+        const seen = this.seen.get(schema32);
         if (seen) {
           seen.count++;
-          const isCycle = _params.schemaPath.includes(schema31);
+          const isCycle = _params.schemaPath.includes(schema32);
           if (isCycle) {
             seen.cycle = _params.path;
           }
           return seen.schema;
         }
         const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
-        this.seen.set(schema31, result);
-        const overrideSchema = schema31._zod.toJSONSchema?.();
+        this.seen.set(schema32, result);
+        const overrideSchema = schema32._zod.toJSONSchema?.();
         if (overrideSchema) {
           result.schema = overrideSchema;
         } else {
           const params = {
             ..._params,
-            schemaPath: [..._params.schemaPath, schema31],
+            schemaPath: [..._params.schemaPath, schema32],
             path: _params.path
           };
-          const parent = schema31._zod.parent;
+          const parent = schema32._zod.parent;
           if (parent) {
             result.ref = parent;
             this.process(parent, params);
@@ -24176,7 +24176,7 @@ var init_to_json_schema = __esm({
               case "string": {
                 const json2 = _json;
                 json2.type = "string";
-                const { minimum, maximum, format, patterns, contentEncoding } = schema31._zod.bag;
+                const { minimum, maximum, format, patterns, contentEncoding } = schema32._zod.bag;
                 if (typeof minimum === "number")
                   json2.minLength = minimum;
                 if (typeof maximum === "number")
@@ -24205,7 +24205,7 @@ var init_to_json_schema = __esm({
               }
               case "number": {
                 const json2 = _json;
-                const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema31._zod.bag;
+                const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema32._zod.bag;
                 if (typeof format === "string" && format.includes("int"))
                   json2.type = "integer";
                 else
@@ -24287,7 +24287,7 @@ var init_to_json_schema = __esm({
               }
               case "array": {
                 const json2 = _json;
-                const { minimum, maximum } = schema31._zod.bag;
+                const { minimum, maximum } = schema32._zod.bag;
                 if (typeof minimum === "number")
                   json2.minItems = minimum;
                 if (typeof maximum === "number")
@@ -24384,7 +24384,7 @@ var init_to_json_schema = __esm({
                     path: [...params.path, "items"]
                   });
                 }
-                const { minimum, maximum } = schema31._zod.bag;
+                const { minimum, maximum } = schema32._zod.bag;
                 if (typeof minimum === "number")
                   json2.minItems = minimum;
                 if (typeof maximum === "number")
@@ -24467,7 +24467,7 @@ var init_to_json_schema = __esm({
                   format: "binary",
                   contentEncoding: "binary"
                 };
-                const { minimum, maximum, mime } = schema31._zod.bag;
+                const { minimum, maximum, mime } = schema32._zod.bag;
                 if (minimum !== void 0)
                   file2.minLength = minimum;
                 if (maximum !== void 0)
@@ -24541,7 +24541,7 @@ var init_to_json_schema = __esm({
               }
               case "template_literal": {
                 const json2 = _json;
-                const pattern = schema31._zod.pattern;
+                const pattern = schema32._zod.pattern;
                 if (!pattern)
                   throw new Error("Pattern not found in template literal");
                 json2.type = "string";
@@ -24571,7 +24571,7 @@ var init_to_json_schema = __esm({
                 break;
               }
               case "lazy": {
-                const innerType = schema31._zod.innerType;
+                const innerType = schema32._zod.innerType;
                 this.process(innerType, params);
                 result.ref = innerType;
                 break;
@@ -24588,20 +24588,20 @@ var init_to_json_schema = __esm({
             }
           }
         }
-        const meta = this.metadataRegistry.get(schema31);
+        const meta = this.metadataRegistry.get(schema32);
         if (meta)
           Object.assign(result.schema, meta);
-        if (this.io === "input" && isTransforming(schema31)) {
+        if (this.io === "input" && isTransforming(schema32)) {
           delete result.schema.examples;
           delete result.schema.default;
         }
         if (this.io === "input" && result.schema._prefault)
           (_a27 = result.schema).default ?? (_a27.default = result.schema._prefault);
         delete result.schema._prefault;
-        const _result = this.seen.get(schema31);
+        const _result = this.seen.get(schema32);
         return _result.schema;
       }
-      emit(schema31, _params) {
+      emit(schema32, _params) {
         const params = {
           cycles: _params?.cycles ?? "ref",
           reused: _params?.reused ?? "inline",
@@ -24609,7 +24609,7 @@ var init_to_json_schema = __esm({
           // uri: _params?.uri ?? ((id) => `${id}`),
           external: _params?.external ?? void 0
         };
-        const root = this.seen.get(schema31);
+        const root = this.seen.get(schema32);
         if (!root)
           throw new Error("Unprocessed schema. This is a bug in Zod.");
         const makeURI = (entry) => {
@@ -24641,11 +24641,11 @@ var init_to_json_schema = __esm({
           seen.def = { ...seen.schema };
           if (defId)
             seen.defId = defId;
-          const schema32 = seen.schema;
-          for (const key2 in schema32) {
-            delete schema32[key2];
+          const schema33 = seen.schema;
+          for (const key2 in schema33) {
+            delete schema33[key2];
           }
-          schema32.$ref = ref;
+          schema33.$ref = ref;
         };
         if (params.cycles === "throw") {
           for (const entry of this.seen.entries()) {
@@ -24659,13 +24659,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
         for (const entry of this.seen.entries()) {
           const seen = entry[1];
-          if (schema31 === entry[0]) {
+          if (schema32 === entry[0]) {
             extractToDef(entry);
             continue;
           }
           if (params.external) {
             const ext = params.external.registry.get(entry[0])?.id;
-            if (schema31 !== entry[0] && ext) {
+            if (schema32 !== entry[0] && ext) {
               extractToDef(entry);
               continue;
             }
@@ -24688,8 +24688,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
         const flattenRef = (zodSchema2, params2) => {
           const seen = this.seen.get(zodSchema2);
-          const schema32 = seen.def ?? seen.schema;
-          const _cached = { ...schema32 };
+          const schema33 = seen.def ?? seen.schema;
+          const _cached = { ...schema33 };
           if (seen.ref === null) {
             return;
           }
@@ -24699,17 +24699,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             flattenRef(ref, params2);
             const refSchema = this.seen.get(ref).schema;
             if (refSchema.$ref && params2.target === "draft-7") {
-              schema32.allOf = schema32.allOf ?? [];
-              schema32.allOf.push(refSchema);
+              schema33.allOf = schema33.allOf ?? [];
+              schema33.allOf.push(refSchema);
             } else {
-              Object.assign(schema32, refSchema);
-              Object.assign(schema32, _cached);
+              Object.assign(schema33, refSchema);
+              Object.assign(schema33, _cached);
             }
           }
           if (!seen.isParent)
             this.override({
               zodSchema: zodSchema2,
-              jsonSchema: schema32,
+              jsonSchema: schema33,
               path: seen.path ?? []
             });
         };
@@ -24725,7 +24725,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           console.warn(`Invalid target: ${this.target}`);
         }
         if (params.external?.uri) {
-          const id = params.external.registry.get(schema31)?.id;
+          const id = params.external.registry.get(schema32)?.id;
           if (!id)
             throw new Error("Schema is missing an `id` property");
           result.$id = params.external.uri(id);
@@ -25267,8 +25267,8 @@ function date3(params) {
 function array(element, params) {
   return _array(ZodArray, element, params);
 }
-function keyof(schema31) {
-  const shape = schema31._zod.def.shape;
+function keyof(schema32) {
+  const shape = schema32._zod.def.shape;
   return literal(Object.keys(shape));
 }
 function object(shape, params) {
@@ -25541,8 +25541,8 @@ function json(params) {
   });
   return jsonSchema2;
 }
-function preprocess(fn, schema31) {
-  return pipe(transform(fn), schema31);
+function preprocess(fn, schema32) {
+  return pipe(transform(fn), schema32);
 }
 var ZodType, _ZodString, ZodString, ZodStringFormat, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodCustomStringFormat, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodBigIntFormat, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodDate, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodEnum, ZodLiteral, ZodFile, ZodTransform, ZodOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodSuccess, ZodCatch, ZodNaN, ZodPipe, ZodReadonly, ZodTemplateLiteral, ZodLazy, ZodPromise, ZodCustom, stringbool;
 var init_schemas2 = __esm({
@@ -27003,30 +27003,30 @@ function floatSafeRemainder2(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-function deepPartialify(schema31) {
-  if (schema31 instanceof ZodObject2) {
+function deepPartialify(schema32) {
+  if (schema32 instanceof ZodObject2) {
     const newShape = {};
-    for (const key2 in schema31.shape) {
-      const fieldSchema = schema31.shape[key2];
+    for (const key2 in schema32.shape) {
+      const fieldSchema = schema32.shape[key2];
       newShape[key2] = ZodOptional2.create(deepPartialify(fieldSchema));
     }
     return new ZodObject2({
-      ...schema31._def,
+      ...schema32._def,
       shape: () => newShape
     });
-  } else if (schema31 instanceof ZodArray2) {
+  } else if (schema32 instanceof ZodArray2) {
     return new ZodArray2({
-      ...schema31._def,
-      type: deepPartialify(schema31.element)
+      ...schema32._def,
+      type: deepPartialify(schema32.element)
     });
-  } else if (schema31 instanceof ZodOptional2) {
-    return ZodOptional2.create(deepPartialify(schema31.unwrap()));
-  } else if (schema31 instanceof ZodNullable2) {
-    return ZodNullable2.create(deepPartialify(schema31.unwrap()));
-  } else if (schema31 instanceof ZodTuple2) {
-    return ZodTuple2.create(schema31.items.map((item) => deepPartialify(item)));
+  } else if (schema32 instanceof ZodOptional2) {
+    return ZodOptional2.create(deepPartialify(schema32.unwrap()));
+  } else if (schema32 instanceof ZodNullable2) {
+    return ZodNullable2.create(deepPartialify(schema32.unwrap()));
+  } else if (schema32 instanceof ZodTuple2) {
+    return ZodTuple2.create(schema32.items.map((item) => deepPartialify(item)));
   } else {
-    return schema31;
+    return schema32;
   }
 }
 function mergeValues2(a, b) {
@@ -28753,9 +28753,9 @@ var init_types = __esm({
         return this.min(1, message);
       }
     };
-    ZodArray2.create = (schema31, params) => {
+    ZodArray2.create = (schema32, params) => {
       return new ZodArray2({
-        type: schema31,
+        type: schema32,
         minLength: null,
         maxLength: null,
         exactLength: null,
@@ -28976,8 +28976,8 @@ var init_types = __esm({
       //   }) as any;
       //   return merged;
       // }
-      setKey(key2, schema31) {
-        return this.augment({ [key2]: schema31 });
+      setKey(key2, schema32) {
+        return this.augment({ [key2]: schema32 });
       }
       // merge<Incoming extends AnyZodObject>(
       //   merging: Incoming
@@ -29385,10 +29385,10 @@ var init_types = __esm({
           status.dirty();
         }
         const items = [...ctx.data].map((item, itemIndex) => {
-          const schema31 = this._def.items[itemIndex] || this._def.rest;
-          if (!schema31)
+          const schema32 = this._def.items[itemIndex] || this._def.rest;
+          if (!schema32)
             return null;
-          return schema31._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+          return schema32._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
         }).filter((x) => !!x);
         if (ctx.common.async) {
           return Promise.all(items).then((results) => {
@@ -29895,9 +29895,9 @@ var init_types = __esm({
         }));
       }
     };
-    ZodPromise2.create = (schema31, params) => {
+    ZodPromise2.create = (schema32, params) => {
       return new ZodPromise2({
-        type: schema31,
+        type: schema32,
         typeName: ZodFirstPartyTypeKind.ZodPromise,
         ...processCreateParams(params)
       });
@@ -30025,17 +30025,17 @@ var init_types = __esm({
         util.assertNever(effect);
       }
     };
-    ZodEffects.create = (schema31, effect, params) => {
+    ZodEffects.create = (schema32, effect, params) => {
       return new ZodEffects({
-        schema: schema31,
+        schema: schema32,
         typeName: ZodFirstPartyTypeKind.ZodEffects,
         effect,
         ...processCreateParams(params)
       });
     };
-    ZodEffects.createWithPreprocess = (preprocess2, schema31, params) => {
+    ZodEffects.createWithPreprocess = (preprocess2, schema32, params) => {
       return new ZodEffects({
-        schema: schema31,
+        schema: schema32,
         effect: { type: "preprocess", transform: preprocess2 },
         typeName: ZodFirstPartyTypeKind.ZodEffects,
         ...processCreateParams(params)
@@ -31184,9 +31184,9 @@ function standardSchemaValidator(standardSchema) {
 }
 async function validateTypes({
   value,
-  schema: schema31
+  schema: schema32
 }) {
-  const result = await safeValidateTypes({ value, schema: schema31 });
+  const result = await safeValidateTypes({ value, schema: schema32 });
   if (!result.success) {
     throw TypeValidationError.wrap({ value, cause: result.error });
   }
@@ -31194,9 +31194,9 @@ async function validateTypes({
 }
 async function safeValidateTypes({
   value,
-  schema: schema31
+  schema: schema32
 }) {
-  const validator22 = asValidator(schema31);
+  const validator22 = asValidator(schema32);
   try {
     if (validator22.validate == null) {
       return { success: true, value, rawValue: value };
@@ -31220,14 +31220,14 @@ async function safeValidateTypes({
 }
 async function parseJSON({
   text: text3,
-  schema: schema31
+  schema: schema32
 }) {
   try {
     const value = secureJsonParse(text3);
-    if (schema31 == null) {
+    if (schema32 == null) {
       return value;
     }
-    return validateTypes({ value, schema: schema31 });
+    return validateTypes({ value, schema: schema32 });
   } catch (error40) {
     if (JSONParseError.isInstance(error40) || TypeValidationError.isInstance(error40)) {
       throw error40;
@@ -31237,14 +31237,14 @@ async function parseJSON({
 }
 async function safeParseJSON({
   text: text3,
-  schema: schema31
+  schema: schema32
 }) {
   try {
     const value = secureJsonParse(text3);
-    if (schema31 == null) {
+    if (schema32 == null) {
       return { success: true, value, rawValue: value };
     }
-    return await safeValidateTypes({ value, schema: schema31 });
+    return await safeValidateTypes({ value, schema: schema32 });
   } catch (error40) {
     return {
       success: false,
@@ -31263,7 +31263,7 @@ function isParsableJson(input) {
 }
 function parseJsonEventStream({
   stream,
-  schema: schema31
+  schema: schema32
 }) {
   return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
     new TransformStream({
@@ -31271,7 +31271,7 @@ function parseJsonEventStream({
         if (data === "[DONE]") {
           return;
         }
-        controller.enqueue(await safeParseJSON({ text: data, schema: schema31 }));
+        controller.enqueue(await safeParseJSON({ text: data, schema: schema32 }));
       }
     })
   );
@@ -31279,14 +31279,14 @@ function parseJsonEventStream({
 async function parseProviderOptions({
   provider,
   providerOptions,
-  schema: schema31
+  schema: schema32
 }) {
   if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
     return void 0;
   }
   const parsedProviderOptions = await safeValidateTypes({
     value: providerOptions[provider],
-    schema: schema31
+    schema: schema32
   });
   if (!parsedProviderOptions.success) {
     throw new InvalidArgumentError({
@@ -31431,12 +31431,12 @@ async function readResponseBodyAsText({
   );
 }
 function lazySchema(createSchema) {
-  let schema31;
+  let schema32;
   return () => {
-    if (schema31 == null) {
-      schema31 = createSchema();
+    if (schema32 == null) {
+      schema32 = createSchema();
     }
-    return schema31;
+    return schema32;
   };
 }
 function jsonSchema(jsonSchema2, {
@@ -31594,13 +31594,13 @@ function parseIntersectionDef(def, refs3) {
     })
   ].filter((x) => !!x);
   const mergedAllOf = [];
-  allOf.forEach((schema31) => {
-    if (isJsonSchema7AllOfType(schema31)) {
-      mergedAllOf.push(...schema31.allOf);
+  allOf.forEach((schema32) => {
+    if (isJsonSchema7AllOfType(schema32)) {
+      mergedAllOf.push(...schema32.allOf);
     } else {
-      let nestedSchema = schema31;
-      if ("additionalProperties" in schema31 && schema31.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema31;
+      let nestedSchema = schema32;
+      if ("additionalProperties" in schema32 && schema32.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema32;
         nestedSchema = rest;
       }
       mergedAllOf.push(nestedSchema);
@@ -31778,44 +31778,44 @@ function escapeNonAlphaNumeric(source) {
   }
   return result;
 }
-function addFormat(schema31, value, message, refs3) {
+function addFormat(schema32, value, message, refs3) {
   var _a27;
-  if (schema31.format || ((_a27 = schema31.anyOf) == null ? void 0 : _a27.some((x) => x.format))) {
-    if (!schema31.anyOf) {
-      schema31.anyOf = [];
+  if (schema32.format || ((_a27 = schema32.anyOf) == null ? void 0 : _a27.some((x) => x.format))) {
+    if (!schema32.anyOf) {
+      schema32.anyOf = [];
     }
-    if (schema31.format) {
-      schema31.anyOf.push({
-        format: schema31.format
+    if (schema32.format) {
+      schema32.anyOf.push({
+        format: schema32.format
       });
-      delete schema31.format;
+      delete schema32.format;
     }
-    schema31.anyOf.push({
+    schema32.anyOf.push({
       format: value,
       ...message && refs3.errorMessages && { errorMessage: { format: message } }
     });
   } else {
-    schema31.format = value;
+    schema32.format = value;
   }
 }
-function addPattern(schema31, regex, message, refs3) {
+function addPattern(schema32, regex, message, refs3) {
   var _a27;
-  if (schema31.pattern || ((_a27 = schema31.allOf) == null ? void 0 : _a27.some((x) => x.pattern))) {
-    if (!schema31.allOf) {
-      schema31.allOf = [];
+  if (schema32.pattern || ((_a27 = schema32.allOf) == null ? void 0 : _a27.some((x) => x.pattern))) {
+    if (!schema32.allOf) {
+      schema32.allOf = [];
     }
-    if (schema31.pattern) {
-      schema31.allOf.push({
-        pattern: schema31.pattern
+    if (schema32.pattern) {
+      schema32.allOf.push({
+        pattern: schema32.pattern
       });
-      delete schema31.pattern;
+      delete schema32.pattern;
     }
-    schema31.allOf.push({
+    schema32.allOf.push({
       pattern: stringifyRegExpWithFlags(regex, refs3),
       ...message && refs3.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    schema31.pattern = stringifyRegExpWithFlags(regex, refs3);
+    schema32.pattern = stringifyRegExpWithFlags(regex, refs3);
   }
 }
 function stringifyRegExpWithFlags(regex, refs3) {
@@ -31902,7 +31902,7 @@ function stringifyRegExpWithFlags(regex, refs3) {
 }
 function parseRecordDef(def, refs3) {
   var _a27, _b24, _c, _d, _e, _f;
-  const schema31 = {
+  const schema32 = {
     type: "object",
     additionalProperties: (_a27 = parseDef(def.valueType._def, {
       ...refs3,
@@ -31912,12 +31912,12 @@ function parseRecordDef(def, refs3) {
   if (((_b24 = def.keyType) == null ? void 0 : _b24._def.typeName) === ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
     const { type, ...keyType } = parseStringDef(def.keyType._def, refs3);
     return {
-      ...schema31,
+      ...schema32,
       propertyNames: keyType
     };
   } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind.ZodEnum) {
     return {
-      ...schema31,
+      ...schema32,
       propertyNames: {
         enum: def.keyType._def.values
       }
@@ -31928,11 +31928,11 @@ function parseRecordDef(def, refs3) {
       refs3
     );
     return {
-      ...schema31,
+      ...schema32,
       propertyNames: keyType
     };
   }
-  return schema31;
+  return schema32;
 }
 function parseMapDef(def, refs3) {
   if (refs3.mapStrategy === "record") {
@@ -32140,9 +32140,9 @@ function decideAdditionalProperties(def, refs3) {
       return refs3.removeAdditionalStrategy === "strict" ? refs3.allowedAdditionalProperties : refs3.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional(schema31) {
+function safeIsOptional(schema32) {
   try {
-    return schema31.isOptional();
+    return schema32.isOptional();
   } catch (e) {
     return true;
   }
@@ -32155,18 +32155,18 @@ function parseSetDef(def, refs3) {
     ...refs3,
     currentPath: [...refs3.currentPath, "items"]
   });
-  const schema31 = {
+  const schema32 = {
     type: "array",
     uniqueItems: true,
     items
   };
   if (def.minSize) {
-    schema31.minItems = def.minSize.value;
+    schema32.minItems = def.minSize.value;
   }
   if (def.maxSize) {
-    schema31.maxItems = def.maxSize.value;
+    schema32.maxItems = def.maxSize.value;
   }
-  return schema31;
+  return schema32;
 }
 function parseTupleDef(def, refs3) {
   if (def.rest) {
@@ -32297,11 +32297,11 @@ function zodSchema(zodSchema2, options) {
 function isSchema(value) {
   return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
 }
-function asSchema(schema31) {
-  return schema31 == null ? jsonSchema({
+function asSchema(schema32) {
+  return schema32 == null ? jsonSchema({
     properties: {},
     additionalProperties: false
-  }) : isSchema(schema31) ? schema31 : typeof schema31 === "function" ? schema31() : zodSchema(schema31);
+  }) : isSchema(schema32) ? schema32 : typeof schema32 === "function" ? schema32() : zodSchema(schema32);
 }
 function convertBase64ToUint8Array(base64String) {
   const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
@@ -33077,7 +33077,7 @@ var init_dist4 = __esm({
         )
       };
     };
-    zodToJsonSchema = (schema31, options) => {
+    zodToJsonSchema = (schema32, options) => {
       var _a27;
       const refs3 = getRefs(options);
       let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
@@ -33099,7 +33099,7 @@ var init_dist4 = __esm({
       ) : void 0;
       const name26 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
       const main2 = (_a27 = parseDef(
-        schema31._def,
+        schema32._def,
         name26 === void 0 ? refs3 : {
           ...refs3,
           currentPath: [...refs3.basePath, refs3.definitionPath, name26]
@@ -37287,8 +37287,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema31 = asSchema(tool2.inputSchema);
-  const parseResult = toolCall.input.trim() === "" ? await safeValidateTypes({ value: {}, schema: schema31 }) : await safeParseJSON({ text: toolCall.input, schema: schema31 });
+  const schema32 = asSchema(tool2.inputSchema);
+  const parseResult = toolCall.input.trim() === "" ? await safeValidateTypes({ value: {}, schema: schema32 }) : await safeParseJSON({ text: toolCall.input, schema: schema32 });
   if (parseResult.success === false) {
     throw new InvalidToolInputError({
       toolName,
@@ -40427,14 +40427,14 @@ function extractReasoningContent(content) {
 }
 function getOutputStrategy({
   output,
-  schema: schema31,
+  schema: schema32,
   enumValues
 }) {
   switch (output) {
     case "object":
-      return objectOutputStrategy(asSchema(schema31));
+      return objectOutputStrategy(asSchema(schema32));
     case "array":
-      return arrayOutputStrategy(asSchema(schema31));
+      return arrayOutputStrategy(asSchema(schema32));
     case "enum":
       return enumOutputStrategy(enumValues);
     case "no-schema":
@@ -40500,7 +40500,7 @@ async function parseAndValidateObjectResultWithRepair(result, outputStrategy, re
 }
 function validateObjectGenerationInput({
   output,
-  schema: schema31,
+  schema: schema32,
   schemaName,
   schemaDescription,
   enumValues
@@ -40513,10 +40513,10 @@ function validateObjectGenerationInput({
     });
   }
   if (output === "no-schema") {
-    if (schema31 != null) {
+    if (schema32 != null) {
       throw new InvalidArgumentError2({
         parameter: "schema",
-        value: schema31,
+        value: schema32,
         message: "Schema is not supported for no-schema output."
       });
     }
@@ -40543,10 +40543,10 @@ function validateObjectGenerationInput({
     }
   }
   if (output === "object") {
-    if (schema31 == null) {
+    if (schema32 == null) {
       throw new InvalidArgumentError2({
         parameter: "schema",
-        value: schema31,
+        value: schema32,
         message: "Schema is required for object output."
       });
     }
@@ -40559,10 +40559,10 @@ function validateObjectGenerationInput({
     }
   }
   if (output === "array") {
-    if (schema31 == null) {
+    if (schema32 == null) {
       throw new InvalidArgumentError2({
         parameter: "schema",
-        value: schema31,
+        value: schema32,
         message: "Element schema is required for array output."
       });
     }
@@ -40575,10 +40575,10 @@ function validateObjectGenerationInput({
     }
   }
   if (output === "enum") {
-    if (schema31 != null) {
+    if (schema32 != null) {
       throw new InvalidArgumentError2({
         parameter: "schema",
-        value: schema31,
+        value: schema32,
         message: "Schema is not supported for enum output."
       });
     }
@@ -44725,9 +44725,9 @@ var init_dist6 = __esm({
         });
       }
     };
-    objectOutputStrategy = (schema31) => ({
+    objectOutputStrategy = (schema32) => ({
       type: "object",
-      jsonSchema: schema31.jsonSchema,
+      jsonSchema: schema32.jsonSchema,
       async validatePartialResult({ value, textDelta }) {
         return {
           success: true,
@@ -44739,7 +44739,7 @@ var init_dist6 = __esm({
         };
       },
       async validateFinalResult(value) {
-        return safeValidateTypes({ value, schema: schema31 });
+        return safeValidateTypes({ value, schema: schema32 });
       },
       createElementStream() {
         throw new UnsupportedFunctionalityError({
@@ -44747,8 +44747,8 @@ var init_dist6 = __esm({
         });
       }
     });
-    arrayOutputStrategy = (schema31) => {
-      const { $schema, ...itemSchema } = schema31.jsonSchema;
+    arrayOutputStrategy = (schema32) => {
+      const { $schema, ...itemSchema } = schema32.jsonSchema;
       return {
         type: "array",
         // wrap in object that contains array of elements, since most LLMs will not
@@ -44783,7 +44783,7 @@ var init_dist6 = __esm({
           const resultArray = [];
           for (let i = 0; i < inputArray.length; i++) {
             const element = inputArray[i];
-            const result = await safeValidateTypes({ value: element, schema: schema31 });
+            const result = await safeValidateTypes({ value: element, schema: schema32 });
             if (i === inputArray.length - 1 && !isFinalDelta) {
               continue;
             }
@@ -44825,7 +44825,7 @@ var init_dist6 = __esm({
           const inputArray = value.elements;
           const resultArray = [];
           for (const element of inputArray) {
-            const result = await safeValidateTypes({ value: element, schema: schema31 });
+            const result = await safeValidateTypes({ value: element, schema: schema32 });
             if (!result.success) {
               return result;
             }
@@ -45543,12 +45543,12 @@ var init_dist6 = __esm({
     object2 = ({
       schema: inputSchema
     }) => {
-      const schema31 = asSchema(inputSchema);
+      const schema32 = asSchema(inputSchema);
       return {
         type: "object",
         responseFormat: {
           type: "json",
-          schema: schema31.jsonSchema
+          schema: schema32.jsonSchema
         },
         async parsePartial({ text: text22 }) {
           const result = await parsePartialJson(text22);
@@ -45582,7 +45582,7 @@ var init_dist6 = __esm({
           }
           const validationResult = await safeValidateTypes({
             value: parseResult.value,
-            schema: schema31
+            schema: schema32
           });
           if (!validationResult.success) {
             throw new NoObjectGeneratedError({
@@ -52160,9 +52160,9 @@ function standardSchemaValidator2(standardSchema) {
 }
 async function validateTypes2({
   value,
-  schema: schema31
+  schema: schema32
 }) {
-  const result = await safeValidateTypes2({ value, schema: schema31 });
+  const result = await safeValidateTypes2({ value, schema: schema32 });
   if (!result.success) {
     throw TypeValidationError2.wrap({ value, cause: result.error });
   }
@@ -52170,9 +52170,9 @@ async function validateTypes2({
 }
 async function safeValidateTypes2({
   value,
-  schema: schema31
+  schema: schema32
 }) {
-  const validator22 = asValidator2(schema31);
+  const validator22 = asValidator2(schema32);
   try {
     if (validator22.validate == null) {
       return { success: true, value, rawValue: value };
@@ -52196,14 +52196,14 @@ async function safeValidateTypes2({
 }
 async function parseJSON2({
   text: text3,
-  schema: schema31
+  schema: schema32
 }) {
   try {
     const value = secureJsonParse2(text3);
-    if (schema31 == null) {
+    if (schema32 == null) {
       return value;
     }
-    return validateTypes2({ value, schema: schema31 });
+    return validateTypes2({ value, schema: schema32 });
   } catch (error40) {
     if (JSONParseError2.isInstance(error40) || TypeValidationError2.isInstance(error40)) {
       throw error40;
@@ -52213,14 +52213,14 @@ async function parseJSON2({
 }
 async function safeParseJSON2({
   text: text3,
-  schema: schema31
+  schema: schema32
 }) {
   try {
     const value = secureJsonParse2(text3);
-    if (schema31 == null) {
+    if (schema32 == null) {
       return { success: true, value, rawValue: value };
     }
-    return await safeValidateTypes2({ value, schema: schema31 });
+    return await safeValidateTypes2({ value, schema: schema32 });
   } catch (error40) {
     return {
       success: false,
@@ -52239,7 +52239,7 @@ function isParsableJson2(input) {
 }
 function parseJsonEventStream2({
   stream,
-  schema: schema31
+  schema: schema32
 }) {
   return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
     new TransformStream({
@@ -52247,7 +52247,7 @@ function parseJsonEventStream2({
         if (data === "[DONE]") {
           return;
         }
-        controller.enqueue(await safeParseJSON2({ text: data, schema: schema31 }));
+        controller.enqueue(await safeParseJSON2({ text: data, schema: schema32 }));
       }
     })
   );
@@ -52255,14 +52255,14 @@ function parseJsonEventStream2({
 async function parseProviderOptions2({
   provider,
   providerOptions,
-  schema: schema31
+  schema: schema32
 }) {
   if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
     return void 0;
   }
   const parsedProviderOptions = await safeValidateTypes2({
     value: providerOptions[provider],
-    schema: schema31
+    schema: schema32
   });
   if (!parsedProviderOptions.success) {
     throw new InvalidArgumentError3({
@@ -54872,8 +54872,8 @@ function mapAnthropicStopReason({
       return "unknown";
   }
 }
-function sanitizeJsonSchema(schema31) {
-  return sanitizeSchema(schema31);
+function sanitizeJsonSchema(schema32) {
+  return sanitizeSchema(schema32);
 }
 function sanitizeDefinition(definition) {
   if (typeof definition === "boolean" || !isPlainObject2(definition)) {
@@ -54881,47 +54881,47 @@ function sanitizeDefinition(definition) {
   }
   return sanitizeSchema(definition);
 }
-function sanitizeSchema(schema31) {
+function sanitizeSchema(schema32) {
   const result = {};
-  const schemaWithDefs = schema31;
-  if (schema31.$ref != null) {
-    return { $ref: schema31.$ref };
+  const schemaWithDefs = schema32;
+  if (schema32.$ref != null) {
+    return { $ref: schema32.$ref };
   }
-  if (schema31.$schema != null) {
-    result.$schema = schema31.$schema;
+  if (schema32.$schema != null) {
+    result.$schema = schema32.$schema;
   }
-  if (schema31.$id != null) {
-    result.$id = schema31.$id;
+  if (schema32.$id != null) {
+    result.$id = schema32.$id;
   }
-  if (schema31.title != null) {
-    result.title = schema31.title;
+  if (schema32.title != null) {
+    result.title = schema32.title;
   }
-  if (schema31.description != null) {
-    result.description = schema31.description;
+  if (schema32.description != null) {
+    result.description = schema32.description;
   }
-  if (schema31.default !== void 0) {
-    result.default = schema31.default;
+  if (schema32.default !== void 0) {
+    result.default = schema32.default;
   }
-  if (schema31.const !== void 0) {
-    result.const = schema31.const;
+  if (schema32.const !== void 0) {
+    result.const = schema32.const;
   }
-  if (schema31.enum != null) {
-    result.enum = schema31.enum;
+  if (schema32.enum != null) {
+    result.enum = schema32.enum;
   }
-  if (schema31.type != null) {
-    result.type = schema31.type;
+  if (schema32.type != null) {
+    result.type = schema32.type;
   }
-  if (schema31.anyOf != null) {
-    result.anyOf = schema31.anyOf.map(sanitizeDefinition);
-  } else if (schema31.oneOf != null) {
-    result.anyOf = schema31.oneOf.map(sanitizeDefinition);
+  if (schema32.anyOf != null) {
+    result.anyOf = schema32.anyOf.map(sanitizeDefinition);
+  } else if (schema32.oneOf != null) {
+    result.anyOf = schema32.oneOf.map(sanitizeDefinition);
   }
-  if (schema31.allOf != null) {
-    result.allOf = schema31.allOf.map(sanitizeDefinition);
+  if (schema32.allOf != null) {
+    result.allOf = schema32.allOf.map(sanitizeDefinition);
   }
-  if (schema31.definitions != null) {
+  if (schema32.definitions != null) {
     result.definitions = Object.fromEntries(
-      Object.entries(schema31.definitions).map(([name19, definition]) => [
+      Object.entries(schema32.definitions).map(([name19, definition]) => [
         name19,
         sanitizeDefinition(definition)
       ])
@@ -54936,43 +54936,43 @@ function sanitizeSchema(schema31) {
       ])
     );
   }
-  if (schema31.type === "object" || schema31.properties != null) {
-    if (schema31.properties != null) {
+  if (schema32.type === "object" || schema32.properties != null) {
+    if (schema32.properties != null) {
       result.properties = Object.fromEntries(
-        Object.entries(schema31.properties).map(([name19, definition]) => [
+        Object.entries(schema32.properties).map(([name19, definition]) => [
           name19,
           sanitizeDefinition(definition)
         ])
       );
     }
     result.additionalProperties = false;
-    if (schema31.required != null) {
-      result.required = schema31.required;
+    if (schema32.required != null) {
+      result.required = schema32.required;
     }
   }
-  if (schema31.items != null) {
-    result.items = Array.isArray(schema31.items) ? schema31.items.map(sanitizeDefinition) : sanitizeDefinition(schema31.items);
+  if (schema32.items != null) {
+    result.items = Array.isArray(schema32.items) ? schema32.items.map(sanitizeDefinition) : sanitizeDefinition(schema32.items);
   }
-  if (typeof schema31.format === "string" && SUPPORTED_STRING_FORMATS.has(schema31.format)) {
-    result.format = schema31.format;
+  if (typeof schema32.format === "string" && SUPPORTED_STRING_FORMATS.has(schema32.format)) {
+    result.format = schema32.format;
   }
-  const constraintDescription = getConstraintDescription(schema31);
+  const constraintDescription = getConstraintDescription(schema32);
   if (constraintDescription != null) {
     result.description = result.description == null ? constraintDescription : `${result.description}
 ${constraintDescription}`;
   }
   return result;
 }
-function getConstraintDescription(schema31) {
+function getConstraintDescription(schema32) {
   const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap((key2) => {
-    const value = schema31[key2];
+    const value = schema32[key2];
     if (value == null || value === false) {
       return [];
     }
     return `${formatConstraintName(key2)}: ${formatConstraintValue(value)}`;
   });
-  if (typeof schema31.format === "string" && !SUPPORTED_STRING_FORMATS.has(schema31.format)) {
-    descriptions.push(`format: ${schema31.format}`);
+  if (typeof schema32.format === "string" && !SUPPORTED_STRING_FORMATS.has(schema32.format)) {
+    descriptions.push(`format: ${schema32.format}`);
   }
   return descriptions.length === 0 ? void 0 : `${descriptions.join("; ")}.`;
 }
@@ -58411,10 +58411,10 @@ function convertJSONSchemaDefinition(jsonSchema2, isRoot, referenceContext) {
   }
   if (anyOf) {
     if (anyOf.some(
-      (schema31) => typeof schema31 === "object" && (schema31 == null ? void 0 : schema31.type) === "null"
+      (schema32) => typeof schema32 === "object" && (schema32 == null ? void 0 : schema32.type) === "null"
     )) {
       const nonNullSchemas = anyOf.filter(
-        (schema31) => !(typeof schema31 === "object" && (schema31 == null ? void 0 : schema31.type) === "null")
+        (schema32) => !(typeof schema32 === "object" && (schema32 == null ? void 0 : schema32.type) === "null")
       );
       if (nonNullSchemas.length === 1) {
         const converted = convertJSONSchemaDefinition(
@@ -61071,8 +61071,8 @@ function getCustomProvider(db, id) {
   return row ? rowToCustomProvider(row) : null;
 }
 function createCustomProvider(db, input) {
-  const { randomUUID: randomUUID18 } = require("node:crypto");
-  const id = `custom-${randomUUID18().slice(0, 8)}`;
+  const { randomUUID: randomUUID19 } = require("node:crypto");
+  const id = `custom-${randomUUID19().slice(0, 8)}`;
   const modelsJson = input.models ? JSON.stringify(input.models) : null;
   db.insert(customProviders).values({
     id,
@@ -61162,9 +61162,9 @@ function resolveActiveContextWindow(db) {
   if (preset)
     return resolveModelContextWindow(preset.models, model);
   if (providerId.startsWith("custom-")) {
-    const cp = getCustomProvider(db, providerId);
-    if (cp)
-      return resolveModelContextWindow(cp.models, model);
+    const cp2 = getCustomProvider(db, providerId);
+    if (cp2)
+      return resolveModelContextWindow(cp2.models, model);
   }
   return null;
 }
@@ -96393,9 +96393,9 @@ var require_dom = __commonJS({
       if (parent.nodeType === Node5.DOCUMENT_NODE) {
         (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
       }
-      var cp = node.parentNode;
-      if (cp) {
-        cp.removeChild(node);
+      var cp2 = node.parentNode;
+      if (cp2) {
+        cp2.removeChild(node);
       }
       if (node.nodeType === DOCUMENT_FRAGMENT_NODE2) {
         var newFirst = node.firstChild;
@@ -106820,7 +106820,7 @@ var require_loadImage = __commonJS({
     var fs5 = require("fs");
     var fetch4 = global.fetch || require_lib3();
     var isURL = require_is_url();
-    var readFile5 = util2.promisify(fs5.readFile);
+    var readFile6 = util2.promisify(fs5.readFile);
     module2.exports = async (image) => {
       let data = image;
       if (typeof image === "undefined") {
@@ -106833,7 +106833,7 @@ var require_loadImage = __commonJS({
         } else if (/data:image\/([a-zA-Z]*);base64,([^"]*)/.test(image)) {
           data = Buffer.from(image.split(",")[1], "base64");
         } else {
-          data = await readFile5(image);
+          data = await readFile6(image);
         }
       } else if (Buffer.isBuffer(image)) {
         data = image;
@@ -110781,14 +110781,14 @@ function pushCodeUnit(parts, chunk, codeUnit) {
   if (chunk.length >= CHUNK)
     flushChunk(parts, chunk);
 }
-function pushCodePoint(parts, chunk, cp) {
-  if (cp <= 65535) {
-    pushCodeUnit(parts, chunk, cp);
+function pushCodePoint(parts, chunk, cp2) {
+  if (cp2 <= 65535) {
+    pushCodeUnit(parts, chunk, cp2);
     return;
   }
-  cp -= 65536;
-  pushCodeUnit(parts, chunk, 55296 + (cp >> 10));
-  pushCodeUnit(parts, chunk, 56320 + (cp & 1023));
+  cp2 -= 65536;
+  pushCodeUnit(parts, chunk, 55296 + (cp2 >> 10));
+  pushCodeUnit(parts, chunk, 56320 + (cp2 & 1023));
 }
 function decodeUTF8(bytes) {
   const parts = [];
@@ -110821,8 +110821,8 @@ function decodeUTF8(bytes) {
         i++;
         continue;
       }
-      const cp2 = (b1 & 31) << 6 | b23 & 63;
-      pushCodeUnit(parts, chunk, cp2);
+      const cp3 = (b1 & 31) << 6 | b23 & 63;
+      pushCodeUnit(parts, chunk, cp3);
       i += 2;
       continue;
     }
@@ -110841,8 +110841,8 @@ function decodeUTF8(bytes) {
         i++;
         continue;
       }
-      const cp2 = (b1 & 15) << 12 | (b23 & 63) << 6 | b32 & 63;
-      pushCodeUnit(parts, chunk, cp2);
+      const cp3 = (b1 & 15) << 12 | (b23 & 63) << 6 | b32 & 63;
+      pushCodeUnit(parts, chunk, cp3);
       i += 3;
       continue;
     }
@@ -110861,8 +110861,8 @@ function decodeUTF8(bytes) {
       i++;
       continue;
     }
-    const cp = (b1 & 7) << 18 | (b22 & 63) << 12 | (b3 & 63) << 6 | b42 & 63;
-    pushCodePoint(parts, chunk, cp);
+    const cp2 = (b1 & 7) << 18 | (b22 & 63) << 12 | (b3 & 63) << 6 | b42 & 63;
+    pushCodePoint(parts, chunk, cp2);
     i += 4;
   }
   flushChunk(parts, chunk);
@@ -118947,7 +118947,7 @@ var init_pdf2 = __esm({
         var defineProperty = Object.defineProperty;
         var stringSlice = uncurryThis("".slice);
         var replace2 = uncurryThis("".replace);
-        var join15 = uncurryThis([].join);
+        var join16 = uncurryThis([].join);
         var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
           return defineProperty(function() {
           }, "length", { value: 8 }).length !== 8;
@@ -118980,7 +118980,7 @@ var init_pdf2 = __esm({
           }
           var state = enforceInternalState(value);
           if (!hasOwn(state, "source")) {
-            state.source = join15(TEMPLATE, typeof name19 == "string" ? name19 : "");
+            state.source = join16(TEMPLATE, typeof name19 == "string" ? name19 : "");
           }
           return value;
         };
@@ -121644,7 +121644,7 @@ var init_pdf2 = __esm({
         var charAt = uncurryThis("".charAt);
         var Uint8Array2 = globalThis2.Uint8Array;
         var $Array = globalThis2.Array;
-        var join15 = uncurryThis([].join);
+        var join16 = uncurryThis([].join);
         var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array2 || !Uint8Array2.prototype.toBase64 || !function() {
           try {
             var target = new Uint8Array2();
@@ -121692,7 +121692,7 @@ var init_pdf2 = __esm({
                   result[written++] = "=";
                 }
               }
-              return join15(result, "");
+              return join16(result, "");
             }
           });
       },
@@ -121704,7 +121704,7 @@ var init_pdf2 = __esm({
         var anUint8Array = __webpack_require__4(4154);
         var notDetached = __webpack_require__4(5169);
         var numberToString2 = uncurryThis(1.1.toString);
-        var join15 = uncurryThis([].join);
+        var join16 = uncurryThis([].join);
         var $Array = Array;
         var Uint8Array2 = globalThis2.Uint8Array;
         var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array2 || !Uint8Array2.prototype.toHex || !function() {
@@ -121725,7 +121725,7 @@ var init_pdf2 = __esm({
                 var hex = numberToString2(this[i], 16);
                 result[i] = hex.length === 1 ? "0" + hex : hex;
               }
-              return join15(result, "");
+              return join16(result, "");
             }
           });
       },
@@ -158174,7 +158174,7 @@ var init_pdf_worker = __esm({
         var defineProperty = Object.defineProperty;
         var stringSlice = uncurryThis("".slice);
         var replace2 = uncurryThis("".replace);
-        var join15 = uncurryThis([].join);
+        var join16 = uncurryThis([].join);
         var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function() {
           return defineProperty(function() {
           }, "length", { value: 8 }).length !== 8;
@@ -158207,7 +158207,7 @@ var init_pdf_worker = __esm({
           }
           var state = enforceInternalState(value);
           if (!hasOwn(state, "source")) {
-            state.source = join15(TEMPLATE, typeof name19 == "string" ? name19 : "");
+            state.source = join16(TEMPLATE, typeof name19 == "string" ? name19 : "");
           }
           return value;
         };
@@ -160457,7 +160457,7 @@ var init_pdf_worker = __esm({
         var charAt = uncurryThis("".charAt);
         var Uint8Array2 = globalThis2.Uint8Array;
         var $Array = globalThis2.Array;
-        var join15 = uncurryThis([].join);
+        var join16 = uncurryThis([].join);
         var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array2 || !Uint8Array2.prototype.toBase64 || !function() {
           try {
             var target = new Uint8Array2();
@@ -160505,7 +160505,7 @@ var init_pdf_worker = __esm({
                   result[written++] = "=";
                 }
               }
-              return join15(result, "");
+              return join16(result, "");
             }
           });
       },
@@ -160517,7 +160517,7 @@ var init_pdf_worker = __esm({
         var anUint8Array = __webpack_require__4(4154);
         var notDetached = __webpack_require__4(5169);
         var numberToString2 = uncurryThis(1.1.toString);
-        var join15 = uncurryThis([].join);
+        var join16 = uncurryThis([].join);
         var $Array = Array;
         var Uint8Array2 = globalThis2.Uint8Array;
         var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array2 || !Uint8Array2.prototype.toHex || !function() {
@@ -160538,7 +160538,7 @@ var init_pdf_worker = __esm({
                 var hex = numberToString2(this[i], 16);
                 result[i] = hex.length === 1 ? "0" + hex : hex;
               }
-              return join15(result, "");
+              return join16(result, "");
             }
           });
       },
@@ -274018,16 +274018,16 @@ var require_pdf_worker = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -274540,7 +274540,7 @@ var require_pdf_worker = __commonJS({
                 includes: function includes(searchElement) {
                   return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : void 0);
                 },
-                join: function join15(separator) {
+                join: function join16(separator) {
                   return arrayJoin.apply(validate(this), arguments);
                 },
                 lastIndexOf: function lastIndexOf(searchElement) {
@@ -301244,16 +301244,16 @@ var require_pdf = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -301760,7 +301760,7 @@ var require_pdf = __commonJS({
                 includes: function includes(searchElement) {
                   return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : void 0);
                 },
-                join: function join15(separator) {
+                join: function join16(separator) {
                   return arrayJoin.apply(validate(this), arguments);
                 },
                 lastIndexOf: function lastIndexOf(searchElement) {
@@ -336583,16 +336583,16 @@ var require_pdf_worker2 = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -337105,7 +337105,7 @@ var require_pdf_worker2 = __commonJS({
                 includes: function includes(searchElement) {
                   return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : void 0);
                 },
-                join: function join15(separator) {
+                join: function join16(separator) {
                   return arrayJoin.apply(validate(this), arguments);
                 },
                 lastIndexOf: function lastIndexOf(searchElement) {
@@ -363915,16 +363915,16 @@ var require_pdf2 = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -364431,7 +364431,7 @@ var require_pdf2 = __commonJS({
                 includes: function includes(searchElement) {
                   return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : void 0);
                 },
-                join: function join15(separator) {
+                join: function join16(separator) {
                   return arrayJoin.apply(validate(this), arguments);
                 },
                 lastIndexOf: function lastIndexOf(searchElement) {
@@ -413526,16 +413526,16 @@ var require_pdf_worker3 = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -427109,16 +427109,16 @@ var require_pdf3 = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -429332,16 +429332,16 @@ var require_pdf_worker4 = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -472867,16 +472867,16 @@ var require_pdf4 = __commonJS({
                             }
                             seenAt = true;
                             for (var i = 0; i < buffer.length; i++) {
-                              var cp = buffer[i];
-                              if (cp === "	" || cp === "\n" || cp === "\r") {
+                              var cp2 = buffer[i];
+                              if (cp2 === "	" || cp2 === "\n" || cp2 === "\r") {
                                 err2("Invalid whitespace in authority.");
                                 continue;
                               }
-                              if (cp === ":" && this._password === null) {
+                              if (cp2 === ":" && this._password === null) {
                                 this._password = "";
                                 continue;
                               }
-                              var tempC = percentEscape(cp);
+                              var tempC = percentEscape(cp2);
                               if (this._password !== null) {
                                 this._password += tempC;
                               } else {
@@ -489877,7 +489877,7 @@ var init_Tokenizer = __esm({
         this.sequenceIndex = 0;
         this.xmlMode = xmlMode;
         this.decodeEntities = decodeEntities2;
-        this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));
+        this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp2, consumed) => this.emitCodePoint(cp2, consumed));
       }
       reset() {
         this.state = State.Text;
@@ -490442,21 +490442,21 @@ var init_Tokenizer = __esm({
           this.cbs.ontext(this.sectionStart, endIndex);
         }
       }
-      emitCodePoint(cp, consumed) {
+      emitCodePoint(cp2, consumed) {
         if (this.baseState !== State.Text && this.baseState !== State.InSpecialTag) {
           if (this.sectionStart < this.entityStart) {
             this.cbs.onattribdata(this.sectionStart, this.entityStart);
           }
           this.sectionStart = this.entityStart + consumed;
           this.index = this.sectionStart - 1;
-          this.cbs.onattribentity(cp);
+          this.cbs.onattribentity(cp2);
         } else {
           if (this.sectionStart < this.entityStart) {
             this.cbs.ontext(this.sectionStart, this.entityStart);
           }
           this.sectionStart = this.entityStart + consumed;
           this.index = this.sectionStart - 1;
-          this.cbs.ontextentity(cp, this.sectionStart);
+          this.cbs.ontextentity(cp2, this.sectionStart);
         }
       }
     };
@@ -490600,10 +490600,10 @@ var init_Parser = __esm({
         this.startIndex = endIndex;
       }
       /** @internal */
-      ontextentity(cp, endIndex) {
+      ontextentity(cp2, endIndex) {
         var _a27, _b20;
         this.endIndex = endIndex - 1;
-        (_b20 = (_a27 = this.cbs).ontext) === null || _b20 === void 0 ? void 0 : _b20.call(_a27, fromCodePoint(cp));
+        (_b20 = (_a27 = this.cbs).ontext) === null || _b20 === void 0 ? void 0 : _b20.call(_a27, fromCodePoint(cp2));
         this.startIndex = endIndex;
       }
       /**
@@ -490724,8 +490724,8 @@ var init_Parser = __esm({
         this.attribvalue += this.getSlice(start, endIndex);
       }
       /** @internal */
-      onattribentity(cp) {
-        this.attribvalue += fromCodePoint(cp);
+      onattribentity(cp2) {
+        this.attribvalue += fromCodePoint(cp2);
       }
       /** @internal */
       onattribend(quote, endIndex) {
@@ -494934,9 +494934,9 @@ function encodeXML2(input) {
       last = index += 1;
       continue;
     }
-    const cp = input.codePointAt(index);
-    out += `&#x${cp.toString(16)};`;
-    if (cp !== char)
+    const cp2 = input.codePointAt(index);
+    out += `&#x${cp2.toString(16)};`;
+    if (cp2 !== char)
       index++;
     last = index += 1;
   }
@@ -506923,10 +506923,10 @@ var require_select = __commonJS({
           if (m[2]) {
             return "";
           }
-          var cp = parseInt(m[1], 16);
-          return String.fromCodePoint ? String.fromCodePoint(cp) : (
+          var cp2 = parseInt(m[1], 16);
+          return String.fromCodePoint ? String.fromCodePoint(cp2) : (
             // Not all JavaScript implementations have String.fromCodePoint yet.
-            String.fromCharCode(cp)
+            String.fromCharCode(cp2)
           );
         });
       } else if (rules.ident.test(str2)) {
@@ -506941,10 +506941,10 @@ var require_select = __commonJS({
         if (!m) {
           return s[1];
         }
-        var cp = parseInt(m[1], 16);
-        return String.fromCodePoint ? String.fromCodePoint(cp) : (
+        var cp2 = parseInt(m[1], 16);
+        return String.fromCodePoint ? String.fromCodePoint(cp2) : (
           // Not all JavaScript implementations have String.fromCodePoint yet.
-          String.fromCharCode(cp)
+          String.fromCharCode(cp2)
         );
       });
     };
@@ -522170,14 +522170,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self2, node);
         }
-        return join15(output, replacement);
+        return join16(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self2 = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join15(output, rule.append(self2.options));
+          output = join16(output, rule.append(self2.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -522190,7 +522190,7 @@ var require_turndown_cjs = __commonJS({
         content = content.trim();
       return whitespace2.leading + rule.replacement(content, node, this.options) + whitespace2.trailing;
     }
-    function join15(output, replacement) {
+    function join16(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -530152,34 +530152,34 @@ function getAssetsRoot() {
   if (assetsRootOverride)
     return assetsRootOverride;
   const { app } = require("electron");
-  return (0, import_node_path13.join)(app.getPath("userData"), "assets");
+  return (0, import_node_path14.join)(app.getPath("userData"), "assets");
 }
 function getCourseAssetsDir(courseId) {
-  return (0, import_node_path13.join)(getAssetsRoot(), courseId);
+  return (0, import_node_path14.join)(getAssetsRoot(), courseId);
 }
 function getAssetFilePath(courseId, filename) {
-  return (0, import_node_path13.join)(getCourseAssetsDir(courseId), filename);
+  return (0, import_node_path14.join)(getCourseAssetsDir(courseId), filename);
 }
 async function copyImageToAssets(sourceAbsPath, courseId, destFilename) {
   const dir = getCourseAssetsDir(courseId);
-  if (!(0, import_node_fs12.existsSync)(dir)) {
-    await (0, import_promises6.mkdir)(dir, { recursive: true });
+  if (!(0, import_node_fs13.existsSync)(dir)) {
+    await (0, import_promises7.mkdir)(dir, { recursive: true });
   }
   const destPath = getAssetFilePath(courseId, destFilename);
-  await (0, import_promises6.copyFile)(sourceAbsPath, destPath);
+  await (0, import_promises7.copyFile)(sourceAbsPath, destPath);
   return destFilename;
 }
 async function writeBufferToAssets(buffer, courseId, destFilename) {
   const dir = getCourseAssetsDir(courseId);
-  if (!(0, import_node_fs12.existsSync)(dir)) {
-    await (0, import_promises6.mkdir)(dir, { recursive: true });
+  if (!(0, import_node_fs13.existsSync)(dir)) {
+    await (0, import_promises7.mkdir)(dir, { recursive: true });
   }
   const destPath = getAssetFilePath(courseId, destFilename);
-  await (0, import_promises6.writeFile)(destPath, buffer);
+  await (0, import_promises7.writeFile)(destPath, buffer);
   return destFilename;
 }
 function persistAssetRecord(db, input) {
-  const id = (0, import_node_crypto16.randomUUID)();
+  const id = (0, import_node_crypto17.randomUUID)();
   const mimeType = input.mimeType ?? inferMime(input.filename);
   db.insert(nodeAssets).values({
     id,
@@ -530217,30 +530217,30 @@ async function getAssetDataUrl(db, assetId) {
   if (!asset)
     return null;
   const filePath = getAssetFilePath(asset.courseId, asset.filename);
-  if (!(0, import_node_fs12.existsSync)(filePath))
+  if (!(0, import_node_fs13.existsSync)(filePath))
     return null;
-  const buf = await (0, import_promises6.readFile)(filePath);
+  const buf = await (0, import_promises7.readFile)(filePath);
   const base643 = buf.toString("base64");
   return `data:${asset.mimeType};base64,${base643}`;
 }
 async function deleteCourseAssetsFiles(courseId) {
   const dir = getCourseAssetsDir(courseId);
-  if (!(0, import_node_fs12.existsSync)(dir))
+  if (!(0, import_node_fs13.existsSync)(dir))
     return;
-  const { rm } = await import("node:fs/promises");
-  await rm(dir, { recursive: true, force: true });
+  const { rm: rm2 } = await import("node:fs/promises");
+  await rm2(dir, { recursive: true, force: true });
 }
-var import_node_path13, import_promises6, import_node_fs12, import_node_crypto16, EXT_MIME, assetsRootOverride;
+var import_node_path14, import_promises7, import_node_fs13, import_node_crypto17, EXT_MIME, assetsRootOverride;
 var init_asset_service = __esm({
   "src/main/services/asset-service.ts"() {
     "use strict";
-    import_node_path13 = require("node:path");
-    import_promises6 = require("node:fs/promises");
-    import_node_fs12 = require("node:fs");
+    import_node_path14 = require("node:path");
+    import_promises7 = require("node:fs/promises");
+    import_node_fs13 = require("node:fs");
     init_drizzle_orm();
     init_schema();
     init_schema();
-    import_node_crypto16 = require("node:crypto");
+    import_node_crypto17 = require("node:crypto");
     init_db2();
     EXT_MIME = {
       png: "image/png",
@@ -530529,7 +530529,7 @@ function applyCourseStructure(db, courseId, proposal) {
   for (const l of allLessons) {
     db.update(contentNodes).set({ parentId: null, orderIdx: 0 }).where(eq(contentNodes.id, l.id)).run();
   }
-  const { randomUUID: randomUUID18 } = require("node:crypto");
+  const { randomUUID: randomUUID19 } = require("node:crypto");
   const validLessonIds = new Set(allLessons.map((l) => l.id));
   const skippedSet = new Set(
     proposal.skippedNodeIds.filter((id) => validLessonIds.has(id))
@@ -530540,7 +530540,7 @@ function applyCourseStructure(db, courseId, proposal) {
     const validIds = sec.lessonIds.filter((id) => validLessonIds.has(id));
     if (validIds.length === 0)
       continue;
-    const sectionId = randomUUID18();
+    const sectionId = randomUUID19();
     const secWorld = sec.world ?? "study";
     db.insert(contentNodes).values({
       id: sectionId,
@@ -530670,9 +530670,9 @@ function applyWorldClassification(db, courseId, classifications) {
     }
   }
   if (orphanPractice.length > 0) {
-    const { randomUUID: randomUUID18 } = require("node:crypto");
+    const { randomUUID: randomUUID19 } = require("node:crypto");
     const maxOrder = Math.max(...sections.map((s) => s.orderIdx), 0);
-    const practiceSectionId = randomUUID18();
+    const practiceSectionId = randomUUID19();
     db.insert(contentNodes).values({
       id: practiceSectionId,
       courseId,
@@ -530925,7 +530925,7 @@ async function persistTranslations(db, courseId, locale, translations) {
       db.update(contentNodeTranslations).set({ title: transTitle, content: transEntry.content }).where(eq(contentNodeTranslations.id, existing.id)).run();
     } else {
       db.insert(contentNodeTranslations).values({
-        id: (0, import_node_crypto24.randomUUID)(),
+        id: (0, import_node_crypto25.randomUUID)(),
         nodeId: node.id,
         courseId,
         locale,
@@ -531005,11 +531005,11 @@ function getCourseTitleTranslations(db, courseId, locale) {
   ).all();
   return new Map(rows.map((r) => [r.nodeId, r.title]));
 }
-var import_node_crypto24;
+var import_node_crypto25;
 var init_translation_service = __esm({
   "src/main/services/translation-service.ts"() {
     "use strict";
-    import_node_crypto24 = require("node:crypto");
+    import_node_crypto25 = require("node:crypto");
     init_drizzle_orm();
     init_dist6();
     init_schema();
@@ -531020,14 +531020,14 @@ var init_translation_service = __esm({
 
 // src/main/serve/index.ts
 var import_node_os4 = require("node:os");
-var import_node_path17 = require("node:path");
+var import_node_path18 = require("node:path");
 
 // src/main/serve/server.ts
 var import_node_http = require("node:http");
 var import_node_https3 = require("node:https");
-var import_node_fs14 = require("node:fs");
-var import_node_path16 = require("node:path");
-var import_node_crypto26 = require("node:crypto");
+var import_node_fs15 = require("node:fs");
+var import_node_path17 = require("node:path");
+var import_node_crypto27 = require("node:crypto");
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -531059,7 +531059,7 @@ function parseClientFrame(raw) {
 }
 
 // src/main/ipc/index.ts
-var import_node_path14 = require("node:path");
+var import_node_path15 = require("node:path");
 init_db2();
 
 // src/main/services/dsh-import-service.ts
@@ -531702,7 +531702,7 @@ function baseResult() {
 // src/main/ipc/index.ts
 init_schema();
 init_drizzle_orm();
-var import_node_crypto25 = require("node:crypto");
+var import_node_crypto26 = require("node:crypto");
 
 // src/main/services/import-plan-store.ts
 var import_node_fs3 = require("node:fs");
@@ -534136,8 +534136,8 @@ function mapRow(row) {
 var HARD = /* @__PURE__ */ new Set(["\u3002", "!", "?", "\uFF01", "\uFF1F", ";", "\uFF1B", "\u2026"]);
 var SOFT = /* @__PURE__ */ new Set([",", "\uFF0C", "\u3001", ":", "\uFF1A", " ", "	"]);
 var EMOJI_CP_RE = /[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}]/u;
-function isEmojiCp(cp) {
-  return cp != null && EMOJI_CP_RE.test(String.fromCodePoint(cp));
+function isEmojiCp(cp2) {
+  return cp2 != null && EMOJI_CP_RE.test(String.fromCodePoint(cp2));
 }
 var CLOSERS = /* @__PURE__ */ new Set(["\u201D", '"', "\u300D", "\u300F", "\u300B", ")", "\u3011", "])".slice(0, 1)]);
 function normalizeSpeechText(md) {
@@ -534178,9 +534178,9 @@ function splitSentences(text3, opts = {}) {
   };
   while (i < n) {
     const ch2 = text3[i];
-    const cp = text3.codePointAt(i);
-    if (isEmojiCp(cp)) {
-      let j = i + (cp > 65535 ? 2 : 1);
+    const cp2 = text3.codePointAt(i);
+    if (isEmojiCp(cp2)) {
+      let j = i + (cp2 > 65535 ? 2 : 1);
       while (j < n) {
         const cj = text3.codePointAt(j);
         const ul = cj > 65535 ? 2 : 1;
@@ -560396,6 +560396,454 @@ function setCompanionPackVehicle(dataDir, id, vehicle) {
   return { ok: true };
 }
 
+// src/main/services/shimeji/shimeji-pack-service.ts
+var import_node_path13 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_fs12 = require("node:fs");
+var import_node_crypto15 = require("node:crypto");
+init_esm2();
+init_schema();
+init_schema();
+init_drizzle_orm();
+
+// src/main/services/shimeji/pure/shimeji-parse.ts
+var ACTION_KIND_MAP = {
+  "\u7D44\u307F\u8FBC\u307F": "Embedded",
+  Embedded: "Embedded",
+  "\u9759\u6B62": "Stay",
+  Stay: "Stay",
+  "\u79FB\u52D5": "Move",
+  Move: "Move",
+  "\u56FA\u5B9A": "Animate",
+  Animate: "Animate",
+  "\u8907\u5408": "Sequence",
+  Sequence: "Sequence"
+};
+function pickAttr(tag, names) {
+  for (const n of names) {
+    const m = tag.match(new RegExp(`${n}="([^"]*)"`));
+    if (m)
+      return m[1];
+  }
+  return void 0;
+}
+function parsePoint(v) {
+  if (!v)
+    return [0, 0];
+  const parts = v.split(",").map((s) => Number(s.trim()));
+  return [Number.isFinite(parts[0]) ? parts[0] : 0, Number.isFinite(parts[1]) ? parts[1] : 0];
+}
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+function normalizeImage(v) {
+  const base = v.split("/").pop() ?? v;
+  return base.trim();
+}
+function parseShimejiActions(xml) {
+  const text3 = stripBom(xml);
+  const actions = [];
+  const opens = [];
+  const re2 = /<(?:動作|Action)(?=[\s/>])/g;
+  let m;
+  while (m = re2.exec(text3))
+    opens.push(m.index);
+  for (let i = 0; i < opens.length; i++) {
+    const start = opens[i];
+    const end = i + 1 < opens.length ? opens[i + 1] : text3.length;
+    const block = text3.slice(start, end);
+    const openTag = block.slice(0, block.indexOf(">") + 1);
+    const name19 = pickAttr(openTag, ["\u540D\u524D", "Name"]);
+    if (!name19)
+      continue;
+    const kindRaw = pickAttr(openTag, ["\u7A2E\u985E", "Type"]) ?? "Embedded";
+    const kind = ACTION_KIND_MAP[kindRaw] ?? "Embedded";
+    const className = pickAttr(openTag, ["\u30AF\u30E9\u30B9", "Class"]);
+    const poses = [];
+    const poseRe = /<(?:ポーズ|Pose)(?=[\s/>])[^>]*>/g;
+    let pm;
+    while (pm = poseRe.exec(block)) {
+      const attrs = pm[0].slice(1, -1);
+      const image = normalizeImage(pickAttr(attrs, ["\u753B\u50CF", "Image"]) ?? "");
+      if (!image)
+        continue;
+      poses.push({
+        image,
+        anchor: parsePoint(pickAttr(attrs, ["\u57FA\u6E96\u5EA7\u6A19", "ImageAnchor"])),
+        velocity: parsePoint(pickAttr(attrs, ["\u79FB\u52D5\u901F\u5EA6", "Velocity"])),
+        duration: Number(pickAttr(attrs, ["\u9577\u3055", "Duration"]) ?? 1) || 1
+      });
+    }
+    actions.push({ name: name19, kind, ...className ? { className } : {}, poses });
+  }
+  return actions;
+}
+function parseShimejiBehaviors(xml) {
+  const text3 = stripBom(xml);
+  const behaviors = [];
+  const opens = [];
+  const re2 = /<(?:行動|Behavior)(?=[\s/>])/g;
+  let m;
+  while (m = re2.exec(text3))
+    opens.push(m.index);
+  for (let i = 0; i < opens.length; i++) {
+    const block = text3.slice(opens[i], i + 1 < opens.length ? opens[i + 1] : text3.length);
+    const openTag = block.slice(0, block.indexOf(">") + 1);
+    const name19 = pickAttr(openTag, ["\u540D\u524D", "Name"]);
+    if (!name19)
+      continue;
+    const frequency = Number(pickAttr(openTag, ["\u983B\u5EA6", "Frequency"]) ?? 0) || 0;
+    const next = [];
+    const refRe = /<(?:行動参照|BehaviorReference)(?=[\s/>])[^>]*>/g;
+    let rm2;
+    while (rm2 = refRe.exec(block)) {
+      const n = pickAttr(rm2[0], ["\u540D\u524D", "Name"]);
+      if (n)
+        next.push({ name: n, frequency: Number(pickAttr(rm2[0], ["\u983B\u5EA6", "Frequency"]) ?? 1) || 1 });
+    }
+    behaviors.push({ name: name19, frequency, next });
+  }
+  return behaviors;
+}
+var ACTION_ARCHIVE = [
+  // ── 地面系(scene·ground) ──
+  { en: "Stand", ja: "\u7ACB\u3064", archive: "scene", slot: "ground" },
+  { en: "Walk", ja: "\u6B69\u304F", archive: "scene", slot: "ground" },
+  { en: "Run", ja: "\u8D70\u308B", archive: "scene", slot: "ground" },
+  { en: "Dash", ja: "\u731B\u30C0\u30C3\u30B7\u30E5", archive: "scene", slot: "ground" },
+  { en: "Sit", ja: "\u5EA7\u308B", archive: "scene", slot: "ground" },
+  { en: "SitAndLookUp", ja: "\u5EA7\u3063\u3066\u898B\u4E0A\u3052\u308B", archive: "scene", slot: "ground" },
+  { en: "SitWithLegsUp", ja: "\u697D\u306B\u5EA7\u308B", archive: "scene", slot: "ground" },
+  { en: "SitWithLegsDown", ja: "\u8DB3\u3092\u4E0B\u308D\u3057\u3066\u5EA7\u308B", archive: "scene", slot: "ground" },
+  { en: "SitAndDangleLegs", ja: "\u5EA7\u3063\u3066\u8DB3\u3092\u3076\u3089\u3076\u3089\u3055\u305B\u308B", archive: "scene", slot: "ground" },
+  { en: "Sprawl", ja: "\u5BDD\u305D\u3079\u308B", archive: "scene", slot: "ground", note: "\u5B66\u4E60\u8005\u6CA1\u52B2\u2192\u8EBA\u5E73(\u4F34\u5B66\u4E8B\u4EF6)" },
+  { en: "Creep", ja: "\u305A\u308A\u305A\u308A", archive: "scene", slot: "ground" },
+  { en: "WalkAlongWorkAreaFloor", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u3092\u6B69\u304F", archive: "scene", slot: "ground" },
+  { en: "RunAlongWorkAreaFloor", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u3092\u8D70\u308B", archive: "scene", slot: "ground" },
+  { en: "CrawlAlongWorkAreaFloor", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u3067\u305A\u308A\u305A\u308A", archive: "scene", slot: "ground" },
+  { en: "WalkLeftAlongFloorAndSit", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "ground" },
+  { en: "WalkRightAlongFloorAndSit", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u306E\u53F3\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "ground" },
+  { en: "WalkLeftAndSit", ja: "\u8D70\u3063\u3066\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "ground" },
+  { en: "WalkRightAndSit", ja: "\u8D70\u3063\u3066\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u306E\u53F3\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "ground" },
+  // ── 交互系(scene·interact/celebrate/tired) ──
+  { en: "Fall", ja: "\u843D\u4E0B\u3059\u308B", archive: "scene", slot: "interact" },
+  { en: "Falling", ja: "\u843D\u3061\u308B", archive: "scene", slot: "interact" },
+  { en: "Dragged", ja: "\u30C9\u30E9\u30C3\u30B0\u3055\u308C\u308B", archive: "scene", slot: "interact" },
+  { en: "Thrown", ja: "\u6295\u3052\u3089\u308C\u308B", archive: "scene", slot: "interact" },
+  { en: "Resisting", ja: "\u62B5\u6297\u3059\u308B", archive: "scene", slot: "interact" },
+  { en: "Pinched", ja: "\u3064\u307E\u307E\u308C\u308B", archive: "scene", slot: "interact" },
+  { en: "Bouncing", ja: "\u8DF3\u306D\u308B", archive: "scene", slot: "celebrate" },
+  { en: "Jumping", ja: "\u30B8\u30E3\u30F3\u30D7", archive: "scene", slot: "celebrate" },
+  { en: "Tripping", ja: "\u8EE2\u3076", archive: "scene", slot: "interact", note: "\u7403\u649E\u53CD\u5E94\u5E27" },
+  // ── 墙壁系(scene·wall,二期) ──
+  { en: "GrabWall", ja: "\u58C1\u306B\u63B4\u307E\u308B", archive: "scene", slot: "wall" },
+  { en: "ClimbWall", ja: "\u58C1\u3092\u767B\u308B", archive: "scene", slot: "wall" },
+  { en: "ClimbHalfwayAlongWall", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u58C1\u3092\u9014\u4E2D\u307E\u3067\u767B\u308B", archive: "scene", slot: "wall" },
+  { en: "ClimbAlongWall", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u58C1\u3092\u767B\u308B", archive: "scene", slot: "wall" },
+  { en: "FallFromWall", ja: "\u58C1\u304B\u3089\u843D\u3061\u308B", archive: "scene", slot: "wall" },
+  { en: "GrabWorkAreaBottomLeftWall", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u304B\u3089\u5DE6\u306E\u58C1\u306B\u3088\u3058\u306E\u307C\u308B", archive: "scene", slot: "wall" },
+  { en: "GrabWorkAreaBottomRightWall", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u304B\u3089\u53F3\u306E\u58C1\u306B\u3088\u3058\u306E\u307C\u308B", archive: "scene", slot: "wall" },
+  { en: "WalkAndGrabBottomLeftWall", ja: "\u8D70\u3063\u3066\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u304B\u3089\u5DE6\u306E\u58C1\u306B\u3088\u3058\u306E\u307C\u308B", archive: "scene", slot: "wall" },
+  { en: "WalkAndGrabBottomRightWall", ja: "\u8D70\u3063\u3066\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0B\u8FBA\u304B\u3089\u53F3\u306E\u58C1\u306B\u3088\u3058\u306E\u307C\u308B", archive: "scene", slot: "wall" },
+  { en: "HoldOntoWall", ja: "\u58C1\u306B\u63B4\u307E\u3063\u3066\u30DC\u30FC\u3063\u3068\u3059\u308B", archive: "scene", slot: "wall" },
+  { en: "JumpFromLeftWall", ja: "\u5DE6\u306E\u58C1\u306B\u98DB\u3073\u3064\u304F", archive: "scene", slot: "wall" },
+  { en: "JumpFromRightWall", ja: "\u53F3\u306E\u58C1\u306B\u98DB\u3073\u3064\u304F", archive: "scene", slot: "wall" },
+  // ── 天花板系(scene·ceiling,二期) ──
+  { en: "GrabCeiling", ja: "\u5929\u4E95\u306B\u63B4\u307E\u308B", archive: "scene", slot: "ceiling" },
+  { en: "ClimbCeiling", ja: "\u5929\u4E95\u3092\u4F1D\u3046", archive: "scene", slot: "ceiling" },
+  { en: "HoldOntoCeiling", ja: "\u5929\u4E95\u306B\u63B4\u307E\u3063\u3066\u30DC\u30FC\u3063\u3068\u3059\u308B", archive: "scene", slot: "ceiling" },
+  { en: "FallFromCeiling", ja: "\u5929\u4E95\u304B\u3089\u843D\u3061\u308B", archive: "scene", slot: "ceiling" },
+  { en: "ClimbAlongCeiling", ja: "\u30EF\u30FC\u30AF\u30A8\u30EA\u30A2\u306E\u4E0A\u8FBA\u3092\u4F1D\u3046", archive: "scene", slot: "ceiling" },
+  // ── 鼠标系(scene·mouse,二期) ──
+  { en: "ChaseMouse", ja: "\u30DE\u30A6\u30B9\u306E\u5468\u308A\u306B\u96C6\u307E\u308B", archive: "scene", slot: "mouse" },
+  { en: "SitAndLookAtMouse", ja: "\u5EA7\u3063\u3066\u30DE\u30A6\u30B9\u306E\u307B\u3046\u3092\u898B\u308B", archive: "scene", slot: "mouse" },
+  { en: "SitAndFaceMouse", ja: "\u5EA7\u3063\u3066\u30DE\u30A6\u30B9\u306E\u307B\u3046\u3092\u898B\u3066\u305F\u3089\u9996\u304C\u56DE\u3063\u305F", archive: "scene", slot: "mouse" },
+  // ── 花活(fx:播动画,无位移语义) ──
+  { en: "SplitIntoTwo", ja: "\u5206\u88C2\u3059\u308B", archive: "fx", note: "\u64AD\u52A8\u753B\u4E0D\u751F\u6210\u7B2C\u4E8C\u53EA(\u5355\u751F\u7269\u8BBE\u5B9A)" },
+  { en: "Divided", ja: "\u5206\u88C2\u3057\u305F", archive: "fx" },
+  { en: "PullUpShimeji", ja: "\u5F15\u3063\u3053\u629C\u304F", archive: "fx" },
+  { en: "PullUpShimeji1", ja: "\u5F15\u3063\u3053\u629C\u304F1", archive: "fx" },
+  { en: "PullUpShimeji2", ja: "\u5F15\u3063\u3053\u629C\u304F2", archive: "fx" },
+  { en: "PullUp", ja: "\u5F15\u3063\u3053\u629C\u304B\u308C\u308B", archive: "fx" },
+  { en: "Look", ja: "\u632F\u308A\u5411\u304F", archive: "fx", note: "\u671D\u5411\u5207\u6362\u5185\u90E8\u7528" },
+  { en: "StandUp", ja: "\u7ACB\u3063\u3066\u30DC\u30FC\u3063\u3068\u3059\u308B", archive: "fx" },
+  { en: "LieDown", ja: "\u5BDD\u305D\u3079\u3063\u3066\u30DC\u30FC\u3063\u3068\u3059\u308B", archive: "fx", slot: "tired" },
+  { en: "SitWhileDanglingLegs", ja: "\u5EA7\u3063\u3066\u8DB3\u3092\u3076\u3089\u3076\u3089\u3055\u305B\u308B(\u8907\u5408)", archive: "fx" },
+  { en: "Bouncing-", ja: "\u8DF3\u306D\u308B(\u8907\u5408)", archive: "fx" },
+  // ── IE/窗口系列(scene·panel,三期;宿主=页面面板) ──
+  { en: "WalkAlongIECeiling", ja: "IE\u306E\u5929\u4E95\u3092\u6B69\u304F", archive: "scene", slot: "panel" },
+  { en: "RunAlongIECeiling", ja: "IE\u306E\u5929\u4E95\u3092\u8D70\u308B", archive: "scene", slot: "panel" },
+  { en: "CrawlAlongIECeiling", ja: "IE\u306E\u5929\u4E95\u3067\u305A\u308A\u305A\u308A", archive: "scene", slot: "panel" },
+  { en: "SitOnTheLeftEdgeOfIE", ja: "IE\u306E\u5929\u4E95\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "panel" },
+  { en: "SitOnTheRightEdgeOfIE", ja: "IE\u306E\u5929\u4E95\u306E\u53F3\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "panel" },
+  { en: "JumpFromLeftEdgeOfIE", ja: "IE\u306E\u5929\u4E95\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u304B\u3089\u98DB\u3073\u964D\u308A\u308B", archive: "scene", slot: "panel" },
+  { en: "JumpFromRightEdgeOfIE", ja: "IE\u306E\u5929\u4E95\u306E\u53F3\u306E\u7AEF\u3063\u3053\u304B\u3089\u98DB\u3073\u964D\u308A\u308B", archive: "scene", slot: "panel" },
+  { en: "WalkLeftAlongIEAndSit", ja: "\u8D70\u3063\u3066IE\u306E\u5929\u4E95\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "panel" },
+  { en: "WalkRightAlongIEAndSit", ja: "\u8D70\u3063\u3066IE\u306E\u5929\u4E95\u306E\u53F3\u306E\u7AEF\u3063\u3053\u3067\u5EA7\u308B", archive: "scene", slot: "panel" },
+  { en: "WalkLeftAlongIEAndJump", ja: "\u8D70\u3063\u3066IE\u306E\u5929\u4E95\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u304B\u3089\u98DB\u3073\u964D\u308A\u308B", archive: "scene", slot: "panel" },
+  { en: "WalkRightAlongIEAndJump", ja: "\u8D70\u3063\u3066IE\u306E\u5929\u4E95\u306E\u53F3\u306E\u7AEF\u3063\u3053\u304B\u3089\u98DB\u3073\u964D\u308A\u308B", archive: "scene", slot: "panel" },
+  { en: "DashIeCeilingLeftEdgeFromJump", ja: "\u731B\u30C0\u30C3\u30B7\u30E5\u3067IE\u306E\u5929\u4E95\u306E\u5DE6\u306E\u7AEF\u3063\u3053\u304B\u3089\u98DB\u3073\u964D\u308A\u308B", archive: "scene", slot: "panel" },
+  { en: "DashIeCeilingRightEdgeFromJump", ja: "\u731B\u30C0\u30C3\u30B7\u30E5\u3067IE\u306E\u5929\u4E95\u306E\u53F3\u306E\u7AEF\u3063\u3053\u304B\u3089\u98DB\u3073\u964D\u308A\u308B", archive: "scene", slot: "panel" },
+  { en: "HoldOntoIEWall", ja: "IE\u306E\u58C1\u3092\u9014\u4E2D\u307E\u3067\u767B\u308B", archive: "scene", slot: "panel" },
+  { en: "ClimbIEWall", ja: "IE\u306E\u58C1\u3092\u767B\u308B", archive: "scene", slot: "panel" },
+  { en: "ClimbIEBottom", ja: "IE\u306E\u4E0B\u8FBA\u3092\u4F1D\u3046", archive: "scene", slot: "panel" },
+  { en: "GrabIEBottomLeftWall", ja: "IE\u306E\u4E0B\u8FBA\u304B\u3089\u5DE6\u306E\u58C1\u306B\u3088\u3058\u306E\u307C\u308B", archive: "scene", slot: "panel" },
+  { en: "GrabIEBottomRightWall", ja: "IE\u306E\u4E0B\u8FBA\u304B\u3089\u53F3\u306E\u58C1\u306B\u3088\u3058\u306E\u307C\u308B", archive: "scene", slot: "panel" },
+  { en: "JumpOnIELeftWall", ja: "IE\u306E\u5DE6\u306B\u98DB\u3073\u3064\u304F", archive: "scene", slot: "panel" },
+  { en: "JumpOnIERightWall", ja: "IE\u306E\u53F3\u306B\u98DB\u3073\u3064\u304F", archive: "scene", slot: "panel" },
+  { en: "JumpFromBottomOfIE", ja: "IE\u306E\u4E0B\u306B\u98DB\u3073\u3064\u304F", archive: "scene", slot: "panel" },
+  { en: "ThrowIEFromLeft", ja: "IE\u3092\u5DE6\u306B\u6295\u3052\u308B", archive: "skip", note: "\u6254\u7A97\u53E3\u65E0\u5BF9\u5E94\u5BBF\u4E3B\u884C\u4E3A" },
+  { en: "ThrowIEFromRight", ja: "IE\u3092\u53F3\u306B\u6295\u3052\u308B", archive: "skip", note: "\u6254\u7A97\u53E3\u65E0\u5BF9\u5E94\u5BBF\u4E3B\u884C\u4E3A" },
+  { en: "WalkAndThrowIEFromLeft", ja: "\u8D70\u3063\u3066IE\u3092\u5DE6\u306B\u6295\u3052\u308B", archive: "skip", note: "\u6254\u7A97\u53E3\u65E0\u5BF9\u5E94\u5BBF\u4E3B\u884C\u4E3A" },
+  { en: "WalkAndThrowIEFromRight", ja: "\u8D70\u3063\u3066IE\u3092\u53F3\u306B\u6295\u3052\u308B", archive: "skip", note: "\u6254\u7A97\u53E3\u65E0\u5BF9\u5E94\u5BBF\u4E3B\u884C\u4E3A" },
+  { en: "FallWithIe", ja: "IE\u3092\u6301\u3063\u3066\u843D\u3061\u308B", archive: "skip", note: "IE \u4E13\u5C5E\u5185\u7F6E\u52A8\u4F5C" },
+  { en: "SitDown", ja: "\u5EA7\u3063\u3066\u30DC\u30FC\u3063\u3068\u3059\u308B", archive: "scene", slot: "ground" },
+  { en: "SitAndSpinHeadAction", ja: "\u5EA7\u3063\u3066\u9996\u304C\u56DE\u308B", archive: "fx" },
+  { en: "SitAndSpinHead", ja: "\u5EA7\u3063\u3066\u30DE\u30A6\u30B9\u306E\u307B\u3046\u3092\u898B\u3066\u305F\u3089\u9996\u304C\u56DE\u3063\u305F", archive: "scene", slot: "mouse" },
+  { en: "Divide1", ja: "\u5206\u88C21", archive: "fx" },
+  { en: "WalkWithIe", ja: "IE\u3092\u6301\u3063\u3066\u6B69\u304F", archive: "skip", note: "IE \u4E13\u5C5E\u5185\u7F6E\u52A8\u4F5C" },
+  { en: "RunWithIe", ja: "IE\u3092\u6301\u3063\u3066\u8D70\u308B", archive: "skip", note: "IE \u4E13\u5C5E\u5185\u7F6E\u52A8\u4F5C" },
+  { en: "ThrowIe", ja: "IE\u3092\u6295\u3052\u308B", archive: "skip", note: "IE \u4E13\u5C5E\u5185\u7F6E\u52A8\u4F5C" },
+  // ── 内置辅助(解析层内部,不上映射) ──
+  { en: "SitAndLookUpAtMouse", ja: "\u5EA7\u3063\u3066\u30DE\u30A6\u30B9\u3092\u898B\u4E0A\u3052\u308B", archive: "scene", slot: "mouse" },
+  { en: "DangleLegs", ja: "\u8DB3\u3092\u3076\u3089\u3076\u3089\u3055\u305B\u308B", archive: "fx" },
+  { en: "Offset", ja: "\u5909\u4F4D", archive: "fx", note: "\u4F4D\u79FB\u52A8\u4F5C\u5185\u90E8\u7528" }
+];
+function archiveOf(actionName) {
+  const hit = ACTION_ARCHIVE.find((e) => e.en === actionName || e.ja === actionName);
+  if (hit)
+    return { entry: hit, archive: hit.archive, ...hit.slot ? { slot: hit.slot } : {} };
+  return { entry: null, archive: "fx" };
+}
+
+// src/main/services/shimeji/shimeji-pack-service.ts
+function getSetting(db, key2) {
+  return db.select().from(settings).where(eq(settings.key, key2)).get()?.value ?? null;
+}
+function setSetting(db, key2, value) {
+  const existing = db.select().from(settings).where(eq(settings.key, key2)).get();
+  if (existing)
+    db.update(settings).set({ value }).where(eq(settings.key, key2)).run();
+  else
+    db.insert(settings).values({ key: key2, value }).run();
+}
+function packsRoot(dataDir) {
+  return (0, import_node_path13.join)(dataDir, "shimeji-packs");
+}
+function stagingRoot(dataDir) {
+  return (0, import_node_path13.join)(packsRoot(dataDir), ".staging");
+}
+async function readJson(path6) {
+  try {
+    return JSON.parse(await (0, import_promises6.readFile)(path6, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function discoverCharacters(files) {
+  const out = [];
+  const confPaths = Object.keys(files).filter((p) => /(^|\/)conf\/[Aa]ctions\.xml$/.test(p));
+  for (const actionsPath of confPaths) {
+    const confDir = actionsPath.replace(/conf\/[Aa]ctions\.xml$/, "").replace(/\/$/, "");
+    const selfImg = confDir ? `${confDir}/img` : "img";
+    const hasSelfImg = Object.keys(files).some((p) => {
+      if (!p.startsWith(`${selfImg}/`) || !p.endsWith(".png"))
+        return false;
+      const rest = p.slice(selfImg.length + 1);
+      if (rest.includes("/"))
+        return false;
+      return rest.toLowerCase() !== "icon.png";
+    });
+    if (hasSelfImg) {
+      out.push({
+        confDir,
+        imgPrefix: selfImg,
+        name: confDir.split("/").pop() ?? "Shimeji",
+        actionsPath
+      });
+      continue;
+    }
+    const imgBase = confDir ? `${confDir}/img` : "img";
+    const breeds = /* @__PURE__ */ new Set();
+    for (const p of Object.keys(files)) {
+      if (!p.startsWith(`${imgBase}/`) || !p.endsWith(".png"))
+        continue;
+      const rest = p.slice(imgBase.length + 1);
+      const breed = rest.includes("/") ? rest.split("/")[0] : "";
+      if (breed)
+        breeds.add(breed);
+    }
+    for (const breed of [...breeds].sort()) {
+      out.push({ confDir, imgPrefix: `${imgBase}/${breed}`, name: breed, actionsPath });
+    }
+  }
+  return out;
+}
+function detectFormat(actionsXmlPath, xml) {
+  const base = actionsXmlPath.split("/").pop() ?? "";
+  if (base === "Actions.xml" && xml.includes("\u30DE\u30B9\u30B3\u30C3\u30C8"))
+    return "\u539F\u7248";
+  if (xml.includes("<Mascot"))
+    return "ee";
+  return xml.includes("\u52D5\u4F5C") ? "\u539F\u7248" : "ee";
+}
+async function importShimejiZip(db, dataDir, zipBase64) {
+  const zipBuf = Buffer.from(zipBase64, "base64");
+  const entries3 = unzipSync(new Uint8Array(zipBuf));
+  const files = {};
+  for (const [path6, data] of Object.entries(entries3)) {
+    if (!path6.startsWith("__MACOSX") && !path6.endsWith("/"))
+      files[path6.replace(/\\/g, "/")] = data;
+  }
+  const chars2 = discoverCharacters(files);
+  if (chars2.length === 0)
+    throw new Error("\u672A\u627E\u5230 Shimeji \u89D2\u8272\u76EE\u5F55(\u9700\u542B conf/Actions.xml \u4E0E img/)");
+  const importId = (0, import_node_crypto15.randomUUID)().slice(0, 8);
+  const stagingDir = (0, import_node_path13.join)(stagingRoot(dataDir), importId);
+  await (0, import_promises6.mkdir)(stagingDir, { recursive: true });
+  for (const [path6, data] of Object.entries(files)) {
+    const target = (0, import_node_path13.join)(stagingDir, path6);
+    await (0, import_promises6.mkdir)((0, import_node_path13.dirname)(target), { recursive: true });
+    await (0, import_promises6.writeFile)(target, data);
+  }
+  const characters = chars2.map((c) => {
+    const xml = new TextDecoder().decode(files[c.actionsPath]);
+    const actions = parseShimejiActions(xml);
+    const frames = Object.keys(files).filter((p) => p.startsWith(`${c.imgPrefix}/`) && p.endsWith(".png") && !p.toLowerCase().endsWith("icon.png"));
+    const iconPath = `${c.imgPrefix}/icon.png`;
+    return {
+      ref: c.imgPrefix,
+      name: c.name,
+      iconBase64: files[iconPath] ? Buffer.from(files[iconPath]).toString("base64") : null,
+      frameCount: frames.length,
+      actionCount: actions.length,
+      format: detectFormat(c.actionsPath, xml)
+    };
+  });
+  return { importId, characters };
+}
+async function confirmShimejiImport(_db2, dataDir, importId, characterRefs) {
+  const stagingDir = (0, import_node_path13.join)(stagingRoot(dataDir), importId);
+  if (!(0, import_node_fs12.existsSync)(stagingDir))
+    throw new Error(`\u5BFC\u5165\u4F1A\u8BDD\u4E0D\u5B58\u5728\u6216\u5DF2\u8FC7\u671F: ${importId}`);
+  const created = [];
+  for (const ref of characterRefs) {
+    const srcImgDir = (0, import_node_path13.join)(stagingDir, ref);
+    if (!(0, import_node_fs12.existsSync)(srcImgDir))
+      continue;
+    const name19 = ref.split("/").pop() ?? ref;
+    const confDir = /\/img(\/[^/]+)?$/.test(ref) ? ref.replace(/\/img(\/[^/]+)?$/, "") : "";
+    const actionsPath = ["Actions.xml", "actions.xml"].map((f) => (0, import_node_path13.join)(stagingDir, confDir, "conf", f)).find((p) => (0, import_node_fs12.existsSync)(p));
+    const xml = await (0, import_promises6.readFile)(actionsPath, "utf8");
+    const format = detectFormat(actionsPath, xml);
+    const actions = parseShimejiActions(xml).map((a) => ({ ...a, slot: archiveOf(a.name).slot }));
+    const behPath = ["Behavior.xml", "behaviors.xml"].map((f) => (0, import_node_path13.join)(stagingDir, confDir, "conf", f)).find((p) => (0, import_node_fs12.existsSync)(p));
+    const behaviors = behPath ? parseShimejiBehaviors(await (0, import_promises6.readFile)(behPath, "utf8")) : [];
+    const packId = `shimeji-${(0, import_node_crypto15.randomUUID)().slice(0, 8)}`;
+    const packDir = (0, import_node_path13.join)(packsRoot(dataDir), packId);
+    await (0, import_promises6.mkdir)(packDir, { recursive: true });
+    await (0, import_promises6.cp)(srcImgDir, (0, import_node_path13.join)(packDir, "img"), { recursive: true });
+    const imgFiles = (await (0, import_promises6.readdir)((0, import_node_path13.join)(packDir, "img"))).filter((f) => f.endsWith(".png") && !f.toLowerCase().endsWith("icon.png"));
+    const manifest = {
+      id: packId,
+      name: name19,
+      format,
+      frames: imgFiles,
+      actions,
+      behaviors,
+      archiveVersion: 1,
+      importedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await (0, import_promises6.writeFile)((0, import_node_path13.join)(packDir, "manifest.json"), JSON.stringify(manifest));
+    created.push({
+      id: packId,
+      name: name19,
+      format,
+      frameCount: imgFiles.length,
+      actionCount: actions.length,
+      iconBase64: (0, import_node_fs12.existsSync)((0, import_node_path13.join)(packDir, "img", "icon.png")) ? (await (0, import_promises6.readFile)((0, import_node_path13.join)(packDir, "img", "icon.png"))).toString("base64") : null,
+      active: false
+    });
+  }
+  await (0, import_promises6.rm)(stagingDir, { recursive: true, force: true });
+  return created;
+}
+async function getShimejiPack(_db2, dataDir, packId) {
+  if (!/^shimeji-[0-9a-f]{8}$/.test(packId))
+    return null;
+  return readJson((0, import_node_path13.join)(packsRoot(dataDir), packId, "manifest.json"));
+}
+async function listShimejiPacks(db, dataDir) {
+  const root = packsRoot(dataDir);
+  if (!(0, import_node_fs12.existsSync)(root))
+    return [];
+  const activeId = db ? getSetting(db, "shimeji_active_pack") ?? null : null;
+  const out = [];
+  for (const dir of (await (0, import_promises6.readdir)(root, { withFileTypes: true })).filter((d) => d.isDirectory() && !d.name.startsWith("."))) {
+    const manifest = await readJson((0, import_node_path13.join)(root, dir.name, "manifest.json"));
+    if (!manifest)
+      continue;
+    let iconBase64 = null;
+    try {
+      iconBase64 = (await (0, import_promises6.readFile)((0, import_node_path13.join)(root, dir.name, "img", "icon.png"))).toString("base64");
+    } catch {
+    }
+    out.push({
+      id: manifest.id,
+      name: manifest.name,
+      format: manifest.format,
+      frameCount: manifest.frames.length,
+      actionCount: manifest.actions.length,
+      iconBase64,
+      active: manifest.id === activeId,
+      vehicle: manifest.vehicle
+    });
+  }
+  return out;
+}
+async function activateShimejiPack(db, packId) {
+  setSetting(db, "shimeji_active_pack", packId);
+}
+var VEH_WHITELIST = /* @__PURE__ */ new Set(["silver", "ember", "frost", "moss", "astro", "ink"]);
+async function setVehicleShimeji(db, dataDir, packId, vehicle) {
+  if (!/^shimeji-[0-9a-f]{8}$/.test(packId))
+    return { ok: false };
+  if (!VEH_WHITELIST.has(vehicle))
+    return { ok: false };
+  const file2 = (0, import_node_path13.join)(packsRoot(dataDir), packId, "manifest.json");
+  const manifest = await readJson(file2);
+  if (!manifest)
+    return { ok: false };
+  manifest.vehicle = vehicle;
+  await (0, import_promises6.writeFile)(file2, JSON.stringify(manifest));
+  return { ok: true };
+}
+async function deleteShimejiPack(db, dataDir, packId) {
+  if (!/^shimeji-[0-9a-f]{8}$/.test(packId))
+    return;
+  if ((getSetting(db, "shimeji_active_pack") ?? null) === packId)
+    db.delete(settings).where(eq(settings.key, "shimeji_active_pack")).run();
+  await (0, import_promises6.rm)((0, import_node_path13.join)(packsRoot(dataDir), packId), { recursive: true, force: true });
+}
+async function getActiveShimejiPack(db, dataDir) {
+  const activeId = getSetting(db, "shimeji_active_pack") ?? null;
+  if (!activeId)
+    return null;
+  return getShimejiPack(db, dataDir, activeId);
+}
+async function getShimejiFrameDataUrl(_db2, dataDir, packId, frame) {
+  if (!/^shimeji-[0-9a-f]{8}$/.test(packId))
+    return null;
+  if (!/^[\w.-]+\.png$/i.test(frame))
+    return null;
+  try {
+    const buf = await (0, import_promises6.readFile)((0, import_node_path13.join)(packsRoot(dataDir), packId, "img", frame));
+    return `data:image/png;base64,${buf.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+
 // src/main/services/progress-service.ts
 init_drizzle_orm();
 init_schema();
@@ -560580,7 +561028,7 @@ function findLessonForPractice(db, practiceNodeId) {
 init_drizzle_orm();
 init_schema();
 init_schema();
-var import_node_crypto15 = require("node:crypto");
+var import_node_crypto16 = require("node:crypto");
 
 // src/main/services/pure/frontmatter.ts
 var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
@@ -560689,7 +561137,7 @@ function getSoul(db, name19) {
   return row ? mapRow2(row) : null;
 }
 function createSoul(db, input) {
-  const id = (0, import_node_crypto15.randomUUID)();
+  const id = (0, import_node_crypto16.randomUUID)();
   db.insert(souls).values({
     id,
     name: input.name,
@@ -560724,7 +561172,7 @@ function seedBuiltinSouls(db) {
       continue;
     const parsed = parseFrontmatter(file2.raw);
     db.insert(souls).values({
-      id: (0, import_node_crypto15.randomUUID)(),
+      id: (0, import_node_crypto16.randomUUID)(),
       name: file2.slug,
       description: parsed.description,
       type: "builtin",
@@ -561242,7 +561690,7 @@ init_schema();
 
 // src/main/services/pure/friction-context.ts
 init_drizzle_orm();
-var import_node_crypto17 = require("node:crypto");
+var import_node_crypto18 = require("node:crypto");
 init_schema();
 var CATEGORY_LABEL = {
   confused: "\u7CCA\u6D82",
@@ -561250,7 +561698,7 @@ var CATEGORY_LABEL = {
   frustrated: "\u53D7\u632B"
 };
 function insertFrictionDb(db, nodeId, category, summary) {
-  db.insert(frictionLog).values({ id: (0, import_node_crypto17.randomUUID)(), nodeId, category, summary }).run();
+  db.insert(frictionLog).values({ id: (0, import_node_crypto18.randomUUID)(), nodeId, category, summary }).run();
 }
 function buildFrictionContext(db, nodeId) {
   const rows = db.select().from(frictionLog).where(
@@ -561408,12 +561856,12 @@ function buildSoulLangReminder(locale) {
 init_drizzle_orm();
 init_schema();
 init_schema();
-var import_node_crypto19 = require("node:crypto");
+var import_node_crypto20 = require("node:crypto");
 
 // src/main/services/kc-service.ts
 init_drizzle_orm();
 init_schema();
-var import_node_crypto18 = require("node:crypto");
+var import_node_crypto19 = require("node:crypto");
 function getKnowledgePoints(db, nodeId) {
   const row = db.select({ kp: contentNodes.knowledgePoints }).from(contentNodes).where(eq(contentNodes.id, nodeId)).get();
   if (!row?.kp)
@@ -561447,7 +561895,7 @@ function ensureKcRows(db, nodeId) {
   for (let i = 0; i < kps.length; i++) {
     if (!existing.has(i)) {
       db.insert(knowledgeComponentMastery).values({
-        id: (0, import_node_crypto18.randomUUID)(),
+        id: (0, import_node_crypto19.randomUUID)(),
         nodeId,
         kcIndex: i,
         mastery: BKT_DEFAULTS.pInit,
@@ -561469,7 +561917,7 @@ function updateKcMastery(db, nodeId, kcIndex, correct) {
     db.update(knowledgeComponentMastery).set({ mastery: newMastery, testedCount: row.testedCount + 1 }).where(eq(knowledgeComponentMastery.id, row.id)).run();
   } else {
     db.insert(knowledgeComponentMastery).values({
-      id: (0, import_node_crypto18.randomUUID)(),
+      id: (0, import_node_crypto19.randomUUID)(),
       nodeId,
       kcIndex,
       mastery: newMastery,
@@ -561575,7 +562023,7 @@ function getXpStatus(db, now2 = /* @__PURE__ */ new Date()) {
 
 // src/main/services/proposal-service.ts
 function createProposal(db, input) {
-  const id = (0, import_node_crypto19.randomUUID)();
+  const id = (0, import_node_crypto20.randomUUID)();
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.insert(proposals).values({
     id,
@@ -561710,7 +562158,7 @@ function executeOperation(db, op) {
     case "add_to_srs": {
       const dueAt = new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
       db.insert(srsItems).values({
-        id: (0, import_node_crypto19.randomUUID)(),
+        id: (0, import_node_crypto20.randomUUID)(),
         nodeId: op.nodeId,
         easeFactor: 250,
         intervalDays: 1,
@@ -561739,7 +562187,7 @@ function mapRow3(row) {
 init_drizzle_orm();
 init_schema();
 init_schema();
-var import_node_crypto20 = require("node:crypto");
+var import_node_crypto21 = require("node:crypto");
 function sqlUtcNow() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
 }
@@ -561794,7 +562242,7 @@ function upsertSlot(db, args) {
     db.update(memory).set({ summary: args.summary, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(memory.id, args.existingId)).run();
   } else {
     db.insert(memory).values({
-      id: (0, import_node_crypto20.randomUUID)(),
+      id: (0, import_node_crypto21.randomUUID)(),
       nodeId: args.nodeId,
       courseId: args.courseId,
       summary: args.summary,
@@ -562736,8 +563184,8 @@ function saveChatHistory(db, nodeId, history2) {
   if (existing) {
     db.update(chatSessions).set({ messagesJson }).where(eq(chatSessions.nodeId, nodeId)).run();
   } else {
-    const { randomUUID: randomUUID18 } = require("node:crypto");
-    db.insert(chatSessions).values({ id: randomUUID18(), nodeId, messagesJson }).run();
+    const { randomUUID: randomUUID19 } = require("node:crypto");
+    db.insert(chatSessions).values({ id: randomUUID19(), nodeId, messagesJson }).run();
   }
 }
 async function handleAgentChatThread(win, threadId, userMessage, displayText, locale, attachments) {
@@ -562852,9 +563300,9 @@ function getContextUsage(db, nodeId, locale) {
   if (preset) {
     visionCapable = supportsVision(preset, model);
   } else if (providerId.startsWith("custom-")) {
-    const cp = getCustomProvider(db, providerId);
-    if (cp) {
-      visionCapable = cp.vision || cp.kind === "vision";
+    const cp2 = getCustomProvider(db, providerId);
+    if (cp2) {
+      visionCapable = cp2.vision || cp2.kind === "vision";
     }
   }
   const override = getVisionOverride(db);
@@ -563004,7 +563452,7 @@ function getDashboard(db, courseId, now2 = /* @__PURE__ */ new Date()) {
 init_drizzle_orm();
 init_schema();
 init_schema();
-var import_node_crypto21 = require("node:crypto");
+var import_node_crypto22 = require("node:crypto");
 function searchContent(sqljs, query2, limit = 10) {
   const terms = query2.trim().split(/\s+/).filter(Boolean);
   if (terms.length === 0)
@@ -563063,7 +563511,7 @@ function updateMemory(db, input) {
       category: existing.category
     };
   }
-  const id = (0, import_node_crypto21.randomUUID)();
+  const id = (0, import_node_crypto22.randomUUID)();
   db.insert(memory).values({ id, nodeId, summary: input.summary, category }).run();
   return { id, nodeId, summary: input.summary, category };
 }
@@ -563084,7 +563532,7 @@ function getMemory(db, nodeId, category) {
 init_drizzle_orm();
 init_schema();
 init_schema();
-var import_node_crypto22 = require("node:crypto");
+var import_node_crypto23 = require("node:crypto");
 init_markdown_course();
 function insertExamNode(db, courseId, sectionId, sectionTitle, orderIdx) {
   const existing = db.select().from(contentNodes).all().find(
@@ -563092,7 +563540,7 @@ function insertExamNode(db, courseId, sectionId, sectionTitle, orderIdx) {
   );
   if (existing)
     return null;
-  const examId = (0, import_node_crypto22.randomUUID)();
+  const examId = (0, import_node_crypto23.randomUUID)();
   db.insert(contentNodes).values({
     id: examId,
     courseId,
@@ -563138,7 +563586,7 @@ function generateCourseFromMarkdown(db, md, opts) {
   let totalExams = 0;
   let firstLessonId = null;
   for (const section2 of parsed.sections) {
-    const sectionId = (0, import_node_crypto22.randomUUID)();
+    const sectionId = (0, import_node_crypto23.randomUUID)();
     db.insert(contentNodes).values({
       id: sectionId,
       courseId,
@@ -563150,7 +563598,7 @@ function generateCourseFromMarkdown(db, md, opts) {
     }).run();
     let lessonOrder = 0;
     for (const lesson of section2.lessons) {
-      const lessonId = (0, import_node_crypto22.randomUUID)();
+      const lessonId = (0, import_node_crypto23.randomUUID)();
       const isFirstEver = firstLessonId === null;
       db.insert(contentNodes).values({
         id: lessonId,
@@ -563215,7 +563663,7 @@ function generateCourseFromRepoFiles(db, parsed, opts) {
   let totalExams = 0;
   let firstLessonId = null;
   for (const section2 of parsed.sections) {
-    const sectionId = (0, import_node_crypto22.randomUUID)();
+    const sectionId = (0, import_node_crypto23.randomUUID)();
     const sectionWorld = section2.world ?? "study";
     db.insert(contentNodes).values({
       id: sectionId,
@@ -563229,7 +563677,7 @@ function generateCourseFromRepoFiles(db, parsed, opts) {
     }).run();
     let lessonOrder = 0;
     for (const lesson of section2.lessons) {
-      const lessonId = (0, import_node_crypto22.randomUUID)();
+      const lessonId = (0, import_node_crypto23.randomUUID)();
       const isFirstEver = firstLessonId === null;
       const lessonWorld = lesson.world ?? sectionWorld;
       db.insert(contentNodes).values({
@@ -563458,8 +563906,8 @@ async function generateExercise(db, nodeId, type, locale) {
   if (!parsed.ok) {
     throw new Error(`AI \u51FA\u9898\u683C\u5F0F\u9519\u8BEF: ${parsed.error}`);
   }
-  const { randomUUID: randomUUID18 } = require("node:crypto");
-  const id = randomUUID18();
+  const { randomUUID: randomUUID19 } = require("node:crypto");
+  const id = randomUUID19();
   db.insert(exercises).values({
     id,
     nodeId,
@@ -563692,7 +564140,7 @@ function setPromise(nodeId, p) {
 }
 
 // src/main/services/exam-service.ts
-var import_node_crypto23 = require("node:crypto");
+var import_node_crypto24 = require("node:crypto");
 var ONE_STAR_THRESHOLD = 0.6;
 var TWO_STAR_THRESHOLD = 0.8;
 var THREE_STAR_THRESHOLD = 0.95;
@@ -563854,7 +564302,7 @@ async function generateExamBank(db, examNodeId, locale) {
     }
     for (const q of collected) {
       db.insert(exercises).values({
-        id: (0, import_node_crypto23.randomUUID)(),
+        id: (0, import_node_crypto24.randomUUID)(),
         nodeId: examNodeId,
         type: "mcq",
         prompt: q.prompt,
@@ -563881,7 +564329,7 @@ function startExamAttempt(db, examNodeId) {
   if (dangling) {
     gradeAndFinalize(db, examNodeId, dangling, safeParseRecord(dangling.answersJson), true);
   }
-  const id = (0, import_node_crypto23.randomUUID)();
+  const id = (0, import_node_crypto24.randomUUID)();
   db.insert(examAttempts).values({
     id,
     examNodeId,
@@ -564436,7 +564884,7 @@ function registerCourseHandlers(deps) {
   );
   let importCancelRequested = false;
   let importRunning = false;
-  const planStore = createPlanStore((0, import_node_path14.join)(deps.dataDir, "import-plans"));
+  const planStore = createPlanStore((0, import_node_path15.join)(deps.dataDir, "import-plans"));
   const runImportJob = (jobId, work) => {
     void (async () => {
       try {
@@ -564462,7 +564910,7 @@ function registerCourseHandlers(deps) {
       return null;
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564482,7 +564930,7 @@ function registerCourseHandlers(deps) {
       throw new Error("\u65E0\u6548\u7684 GitHub URL");
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564503,7 +564951,7 @@ function registerCourseHandlers(deps) {
       throw new Error("\u65E0\u6CD5\u8BC6\u522B\u7684\u94FE\u63A5:\u8BF7\u7C98\u8D34 http(s) \u7F51\u5740\u6216 GitHub \u4ED3\u5E93\u5730\u5740");
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564525,7 +564973,7 @@ function registerCourseHandlers(deps) {
       throw new Error("\u6CA1\u6709\u53EF\u5BFC\u5165\u7684\u6587\u672C\u5185\u5BB9");
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564558,7 +565006,7 @@ function registerCourseHandlers(deps) {
     }
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564591,7 +565039,7 @@ function registerCourseHandlers(deps) {
       throw new Error("\u97F3\u9891\u603B\u91CF\u8D85\u8FC7 200MB \u4E0A\u9650,\u8BF7\u5206\u6279\u5BFC\u5165");
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564620,7 +565068,7 @@ function registerCourseHandlers(deps) {
       throw new Error("\u627E\u4E0D\u5230\u5BF9\u5E94\u7684\u5BFC\u5165\u65B9\u6848\u5FEB\u7167(\u53EF\u80FD\u5DF2\u8FC7\u671F)");
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -564656,7 +565104,7 @@ function registerCourseHandlers(deps) {
       throw new Error("\u8BFE\u7A0B\u5305\u4E0D\u542B\u8BFE\u7A0B\u7ED3\u6784,\u65E0\u6CD5\u76F4\u63A5\u5BFC\u5165");
     if (importRunning)
       throw new Error("\u5DF2\u6709\u5BFC\u5165\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5B83\u7ED3\u675F\u6216\u5148\u53D6\u6D88");
-    const jobId = (0, import_node_crypto25.randomUUID)();
+    const jobId = (0, import_node_crypto26.randomUUID)();
     importRunning = true;
     importCancelRequested = false;
     const shouldAbort = () => importCancelRequested;
@@ -565329,6 +565777,32 @@ function registerCompanionPackHandlers(deps) {
   handle("companionPack:setVehicle", async (_e, input) => {
     return setCompanionPackVehicle(deps.dataDir, input.id, input.vehicle);
   });
+  handle("shimeji:importZip", async (_e, input) => {
+    return importShimejiZip(getDb(), deps.dataDir, input.zipBase64);
+  });
+  handle("shimeji:confirmImport", async (_e, input) => {
+    return { packs: await confirmShimejiImport(getDb(), deps.dataDir, input.importId, input.characterRefs) };
+  });
+  handle("shimeji:list", async () => {
+    return { packs: await listShimejiPacks(getDb(), deps.dataDir) };
+  });
+  handle("shimeji:getActive", async () => {
+    return getActiveShimejiPack(getDb(), deps.dataDir);
+  });
+  handle("shimeji:getFrame", async (_e, input) => {
+    return getShimejiFrameDataUrl(getDb(), deps.dataDir, input.packId, input.frame);
+  });
+  handle("shimeji:activate", async (_e, input) => {
+    await activateShimejiPack(getDb(), input.id);
+    return { ok: true };
+  });
+  handle("shimeji:delete", async (_e, input) => {
+    await deleteShimejiPack(getDb(), deps.dataDir, input.id);
+    return { ok: true };
+  });
+  handle("shimeji:setVehicle", async (_e, input) => {
+    return setVehicleShimeji(getDb(), deps.dataDir, input.id, input.vehicle);
+  });
 }
 function registerThreadHandlers() {
   handle(
@@ -565444,8 +565918,8 @@ init_asset_service();
 
 // src/main/services/seed.ts
 init_db2();
-var import_node_fs13 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path16 = require("node:path");
 var import_node_url = require("node:url");
 
 // src/main/services/seed-apply.ts
@@ -565535,25 +566009,25 @@ function loadSeedData() {
   const fileName = "seed-course.json";
   const candidates = [
     // 便携束(手机/serve):seed-course.json 与 server.cjs 并排(buildServerBundle 复制)
-    (0, import_node_path15.join)(__dirname, fileName),
+    (0, import_node_path16.join)(__dirname, fileName),
     // tsx 直跑(verify 脚本):__dirname = .../src/main/services
-    (0, import_node_path15.join)(__dirname, "..", "assets", fileName),
+    (0, import_node_path16.join)(__dirname, "..", "assets", fileName),
     // dev/prod vite 构建:__dirname = .../dist-electron/main → 项目根 → src/main/assets
-    (0, import_node_path15.join)(__dirname, "..", "..", "src", "main", "assets", fileName),
+    (0, import_node_path16.join)(__dirname, "..", "..", "src", "main", "assets", fileName),
     // 打包后:__dirname 在 resources/app/dist-electron/main → 需把 assets 复制到 dist
-    (0, import_node_path15.join)(__dirname, "assets", fileName)
+    (0, import_node_path16.join)(__dirname, "assets", fileName)
   ];
   let lastErr = null;
   for (const p of candidates) {
     try {
-      return JSON.parse((0, import_node_fs13.readFileSync)(p, "utf8"));
+      return JSON.parse((0, import_node_fs14.readFileSync)(p, "utf8"));
     } catch (e) {
       lastErr = e;
     }
   }
   try {
-    const here = (0, import_node_path15.dirname)((0, import_node_url.fileURLToPath)(import_meta5.url));
-    return JSON.parse((0, import_node_fs13.readFileSync)((0, import_node_path15.join)(here, "..", "assets", fileName), "utf8"));
+    const here = (0, import_node_path16.dirname)((0, import_node_url.fileURLToPath)(import_meta5.url));
+    return JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path16.join)(here, "..", "assets", fileName), "utf8"));
   } catch {
   }
   throw new Error(
@@ -565587,16 +566061,16 @@ var stubDialog = {
   }
 };
 function loadOrCreateToken(dataDir) {
-  const tokenPath = (0, import_node_path16.join)(dataDir, "serve-token");
+  const tokenPath = (0, import_node_path17.join)(dataDir, "serve-token");
   try {
-    const existing = (0, import_node_fs14.readFileSync)(tokenPath, "utf8").trim();
+    const existing = (0, import_node_fs15.readFileSync)(tokenPath, "utf8").trim();
     if (existing.length >= 16)
       return existing;
   } catch {
   }
-  const token = (0, import_node_crypto26.randomBytes)(24).toString("hex");
-  (0, import_node_fs14.mkdirSync)(dataDir, { recursive: true });
-  (0, import_node_fs14.writeFileSync)(tokenPath, token, "utf8");
+  const token = (0, import_node_crypto27.randomBytes)(24).toString("hex");
+  (0, import_node_fs15.mkdirSync)(dataDir, { recursive: true });
+  (0, import_node_fs15.writeFileSync)(tokenPath, token, "utf8");
   return token;
 }
 var MIME2 = {
@@ -565618,9 +566092,9 @@ var MIME2 = {
   ".webmanifest": "application/manifest+json"
 };
 async function startServe(opts) {
-  (0, import_node_fs14.mkdirSync)(opts.dataDir, { recursive: true });
-  setAssetsRoot((0, import_node_path16.join)(opts.dataDir, "assets"));
-  setAttachmentsRoot((0, import_node_path16.join)(opts.dataDir, "attachments"));
+  (0, import_node_fs15.mkdirSync)(opts.dataDir, { recursive: true });
+  setAssetsRoot((0, import_node_path17.join)(opts.dataDir, "assets"));
+  setAttachmentsRoot((0, import_node_path17.join)(opts.dataDir, "attachments"));
   await initDb({ dataDir: opts.dataDir });
   ensureSeedCourse();
   const { patched } = ensureExamNodesForExistingCourses(getDb());
@@ -565630,7 +566104,7 @@ async function startServe(opts) {
   const { ensurePrefLang: ensurePrefLang2 } = await Promise.resolve().then(() => (init_lang_pref(), lang_pref_exports));
   ensurePrefLang2(getDb(), Intl.DateTimeFormat().resolvedOptions().locale || "zh-CN");
   const token = opts.skipAuth ? "" : loadOrCreateToken(opts.dataDir);
-  const webRoot = (0, import_node_path16.resolve)(opts.webDir);
+  const webRoot = (0, import_node_path17.resolve)(opts.webDir);
   const clients = /* @__PURE__ */ new Set();
   const emitter2 = {
     send(channel, ...args) {
@@ -565653,22 +566127,22 @@ async function startServe(opts) {
   const dummyEvent = { sender: null };
   const requestHandler = (req, res) => {
     const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
-    let filePath = (0, import_node_path16.normalize)((0, import_node_path16.join)(webRoot, urlPath));
+    let filePath = (0, import_node_path17.normalize)((0, import_node_path17.join)(webRoot, urlPath));
     if (!filePath.startsWith(webRoot)) {
       res.writeHead(403).end();
       return;
     }
-    if (urlPath === "/" || !(0, import_node_fs14.existsSync)(filePath) || !filePath.includes(".")) {
-      filePath = (0, import_node_path16.join)(webRoot, "index.html");
+    if (urlPath === "/" || !(0, import_node_fs15.existsSync)(filePath) || !filePath.includes(".")) {
+      filePath = (0, import_node_path17.join)(webRoot, "index.html");
     }
-    const mime = MIME2[(0, import_node_path16.extname)(filePath)] ?? "application/octet-stream";
+    const mime = MIME2[(0, import_node_path17.extname)(filePath)] ?? "application/octet-stream";
     res.writeHead(200, { "content-type": mime, "cache-control": "no-cache" });
-    (0, import_node_fs14.createReadStream)(filePath).pipe(res);
+    (0, import_node_fs15.createReadStream)(filePath).pipe(res);
   };
   let httpServer;
   if (opts.tlsCert && opts.tlsKey) {
     httpServer = (0, import_node_https3.createServer)(
-      { cert: (0, import_node_fs14.readFileSync)(opts.tlsCert), key: (0, import_node_fs14.readFileSync)(opts.tlsKey) },
+      { cert: (0, import_node_fs15.readFileSync)(opts.tlsCert), key: (0, import_node_fs15.readFileSync)(opts.tlsKey) },
       requestHandler
     );
   } else {
@@ -565757,11 +566231,11 @@ function argvHas(name19) {
   return process.argv.includes(`--${name19}`);
 }
 async function main() {
-  const dataDir = (0, import_node_path17.resolve)(arg("data", (0, import_node_path17.join)((0, import_node_os4.homedir)(), ".lookatstudy")));
-  const webDir = (0, import_node_path17.resolve)(arg("web", (0, import_node_path17.join)(__dirname, "web")));
+  const dataDir = (0, import_node_path18.resolve)(arg("data", (0, import_node_path18.join)((0, import_node_os4.homedir)(), ".lookatstudy")));
+  const webDir = (0, import_node_path18.resolve)(arg("web", (0, import_node_path18.join)(__dirname, "web")));
   const port = Number(arg("port", "17890"));
-  const tlsCert = argvHas("tls-cert") ? (0, import_node_path17.resolve)(arg("tls-cert", "")) : void 0;
-  const tlsKey = argvHas("tls-key") ? (0, import_node_path17.resolve)(arg("tls-key", "")) : void 0;
+  const tlsCert = argvHas("tls-cert") ? (0, import_node_path18.resolve)(arg("tls-cert", "")) : void 0;
+  const tlsKey = argvHas("tls-key") ? (0, import_node_path18.resolve)(arg("tls-key", "")) : void 0;
   if (tlsCert !== void 0 !== (tlsKey !== void 0)) {
     throw new Error("--tls-cert \u4E0E --tls-key \u5FC5\u987B\u6210\u5BF9\u63D0\u4F9B(PEM \u6587\u4EF6\u8DEF\u5F84)");
   }