akari-video 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "AKARI Video launcher CLI — start an AI-edited video project from any directory: scaffold, connection check, then hand over to Claude Code (or opencode). AKARI Video を opencode や Claude Code で、どのディレクトリからでも始めるための `akari` ランチャー CLI。接続確認（doctor）→ 未セットアップならプロジェクト雛形を作成 → AI エージェントを起動する。外部 npm 依存ゼロ（Node.js 組み込みモジュールのみ）。",
   "type": "module",
   "bin": {

package/vendor/packages/akari-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "AKARI Video launcher CLI — start an AI-edited video project from any directory: scaffold, connection check, then hand over to Claude Code (or opencode). AKARI Video を opencode や Claude Code で、どのディレクトリからでも始めるための `akari` ランチャー CLI。接続確認（doctor）→ 未セットアップならプロジェクト雛形を作成 → AI エージェントを起動する。外部 npm 依存ゼロ（Node.js 組み込みモジュールのみ）。 [akari-video npm vendor: bin/akari.mjs is reference-only. These CLI entrypoints are not included in the akari-video npm package. Use `akari doctor --json` and run the path reported in `render_cut.path`. Full installations provide it in a monorepo checkout, ~/.akari/app, /Applications/AKARI Video.app/Contents/Resources/packages, or %LOCALAPPDATA%\\Programs\\@akari-videoshell\\resources\\packages.]",
   "type": "module",
   "files": [

package/vendor/packages/asset-resolver/src/place-library-asset.mjs

@@ -0,0 +1,54 @@
+import { realpath, stat } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { recordProjectReference } from './project-references.mjs';
+import { appendLibraryUsage } from './library-usage.mjs';
+import { ASSET_CATEGORIES } from './library.mjs';
+import { resolveAssetLibraryRoots } from '../../creator-root/src/index.mjs';
+
+const within = (root, target) => {
+  const rel = relative(root, target);
+  return rel === '' || (rel !== '..' && !rel.startsWith('..' + sep) && !isAbsolute(rel));
+};
+
+export async function placeLibraryAsset(source, projectPath, env = process.env) {
+  if (!source || !ASSET_CATEGORIES.includes(source.category)
+      || typeof source.id !== 'string' || !source.id || source.id === '.'
+      || source.id.includes('..') || source.id.includes('/') || source.id.includes(String.fromCharCode(92))
+      || typeof source.libraryDir !== 'string' || !isAbsolute(source.libraryDir)) {
+    throw new Error('素材の種類・名前・置き場が不正です');
+  }
+  const actual = await realpath(source.libraryDir);
+  if (basename(actual) !== source.id || basename(dirname(actual)) !== source.category
+      || !(await stat(actual)).isDirectory()) {
+    throw new Error('素材の置き場と種類・名前が一致しません');
+  }
+  let allowed = false;
+  for (const root of resolveAssetLibraryRoots(env).read) {
+    try { if (within(await realpath(root), actual)) allowed = true; }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  if (!allowed) throw new Error('素材がライブラリの置き場の外にあります');
+  const project = await realpath(projectPath);
+  if (!(await stat(project)).isDirectory()) throw new Error('プロジェクトがフォルダではありません');
+  const destination = join(project, 'assets', source.category, source.id);
+  let parent = dirname(destination);
+  let actualDestination;
+  while (true) {
+    try {
+      const actualParent = await realpath(parent);
+      if (!within(project, actualParent)) throw new Error('配置先がプロジェクトの外にあります');
+      actualDestination = join(actualParent, relative(parent, destination));
+      break;
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      parent = dirname(parent);
+    }
+  }
+  if (within(actualDestination, actual) || within(actual, actualDestination)) {
+    throw new Error('素材の大元と重なる配置はできません');
+  }
+  await recordProjectReference(project, { category: source.category, id: source.id });
+  await appendLibraryUsage({ category: source.category, id: source.id, project });
+  return { success: true, projectAssetPath: join(projectPath, 'assets', source.category, source.id),
+    reference: true, libraryDir: actual };
+}

package/vendor/packages/asset-resolver/src/project-reference-listing.mjs

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { listProjectReferenceAssets } from './shell-reference.mjs';
+import { sourceFields } from './library.mjs';
+import { readCatalogCache } from './catalog.mjs';
+import { resolveCatalogSource } from './env.mjs';
+
+export async function listProjectAssetReferences(project, env = process.env) {
+  let catalog = await readCatalogCache(env);
+  const source = resolveCatalogSource(env);
+  if (source.kind === 'file') { try { catalog = JSON.parse(await readFile(source.value, 'utf8')); } catch {} }
+  const entries = await listProjectReferenceAssets(project, env);
+  for (const entry of entries) {
+    let meta;
+    try { meta = JSON.parse(await readFile(entry.files.find(file => file.name === 'meta.json').path, 'utf8')); } catch {}
+    entry.tags = Array.isArray(meta?.tags) ? meta.tags.filter(tag => typeof tag === 'string') : [];
+    const known = catalog?.items?.find(item => item.id === entry.id && item.category === entry.category);
+    entry.title = typeof meta?.title === 'string' ? meta.title : typeof known?.title === 'string' ? known.title : entry.id;
+    if (!meta && known) entry.tags = Array.isArray(known.tags) ? known.tags.filter(tag => typeof tag === 'string') : [];
+    if (meta || known) entry.sourceKind = sourceFields(meta ?? known, !!known).sourceKind;
+  }
+  return entries;
+}

package/vendor/packages/asset-resolver/src/project-references.mjs

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { lstatSync, realpathSync } from 'node:fs';
-import fsPromises, { mkdir, open, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import fsPromises, { lstat, realpath, mkdir, open, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { setTimeout as delay } from 'node:timers/promises';
 import path from 'node:path';
 
@@ -219,3 +219,26 @@ export function resolveLibraryFallback({ declaredPath, references, akariAssetsDi
     return null;
   }
 }
+
+export async function resolveLibraryFallbackAsync({ declaredPath, references, akariAssetsDir, rootRealpaths }) {
+  const parsed = parseDeclaredAssetPath(declaredPath);
+  if (!parsed || typeof akariAssetsDir !== 'string' || akariAssetsDir.length === 0) return null;
+  if (!normalizeReferences(references).some(
+    entry => entry.category === parsed.category && entry.id === parsed.id,
+  )) return null;
+  const lexicalRoot = path.resolve(akariAssetsDir);
+  const lexicalTarget = path.resolve(lexicalRoot, parsed.category, parsed.id, ...parsed.rest);
+  if (!isWithin(lexicalRoot, lexicalTarget)) return null;
+  try {
+    let actualRoot = rootRealpaths?.get(lexicalRoot);
+    if (!actualRoot) {
+      actualRoot = realpath(lexicalRoot);
+      rootRealpaths?.set(lexicalRoot, actualRoot);
+    }
+    const [root, target] = await Promise.all([actualRoot, realpath(lexicalTarget)]);
+    if (!isWithin(root, target) || !(await lstat(target)).isFile()) return null;
+    return target;
+  } catch {
+    return null;
+  }
+}

package/vendor/packages/asset-resolver/src/resolve-async-library.mjs

@@ -0,0 +1,113 @@
+import { readdir, stat, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveAssetLibraryRoots } from '../../creator-root/src/index.mjs';
+import { assetTier } from './tier.mjs';
+import { loadCatalog, readCatalogCache } from './catalog.mjs';
+import { mergeInstalledItems, INSTALLED_ASSETS_SCHEMA } from './installed.mjs';
+import { resolveCatalogSource } from './env.mjs';
+
+export async function cachedAssetDirAsync(env, category, id) {
+  for (const root of resolveAssetLibraryRoots(env).read) {
+    const dir = path.resolve(root, category, id);
+    try {
+      if ((await stat(dir)).isDirectory() && (await readdir(dir)).length) return dir;
+    } catch { /* next root */ }
+  }
+  return null;
+}
+
+const safe = value => typeof value === 'string' && value.length > 0
+  && value !== '.' && value !== '..' && !/[\\/]/.test(value);
+
+function within(root, ...parts) {
+  const base = path.resolve(root);
+  const candidate = path.resolve(base, ...parts);
+  if (candidate !== base && !candidate.startsWith(`${base}${path.sep}`)) {
+    throw new Error(`導入済み素材のパスがパック外を指しています: ${parts.join('/')}`);
+  }
+  return candidate;
+}
+
+async function installedItemsAsync(env) {
+  const roots = resolveAssetLibraryRoots(env).read;
+  const byId = new Map();
+  for (const libraryRoot of [...roots].reverse()) {
+    const indexPath = path.join(libraryRoot, 'installed.json');
+    let index;
+    try { index = JSON.parse(await readFile(indexPath, 'utf8')); }
+    catch (error) {
+      if (error?.code === 'ENOENT') continue;
+      throw new Error(`導入済み素材索引を読めません: ${indexPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (index?.schema !== INSTALLED_ASSETS_SCHEMA
+        || !index.packs || typeof index.packs !== 'object' || Array.isArray(index.packs)) {
+      throw new Error(`導入済み素材索引の形式が想定と違います: ${indexPath}`);
+    }
+    for (const [packId, pack] of Object.entries(index.packs)) {
+      if (!safe(packId) || !pack || typeof pack.root !== 'string' || !path.isAbsolute(pack.root)
+          || (typeof pack.version !== 'string' && typeof pack.version !== 'number')
+          || typeof pack.installedAt !== 'string' || !pack.installedAt || !Array.isArray(pack.items)) {
+        throw new Error(`導入済み素材索引に不正な pack があります: ${packId}`);
+      }
+      const originalRoot = roots.find(root => {
+        try { within(path.join(root, 'store', packId), pack.root); return true; } catch { return false; }
+      });
+      if (!originalRoot) throw new Error(`導入済み素材の root がパック外を指しています: ${pack.root}`);
+      const relativeRoot = path.relative(originalRoot, pack.root);
+      const readRoots = roots.map(root => path.join(root, relativeRoot));
+      for (const item of pack.items) {
+        if (!item || !safe(item.id) || typeof item.title !== 'string' || !item.title
+            || typeof item.path !== 'string' || !item.path || item.version == null) {
+          throw new Error(`導入済み素材索引に不正な item があります: ${packId}`);
+        }
+        if (!Array.isArray(item.files) || item.files.length === 0) {
+          throw new Error(`導入済み素材索引の item に files[] がありません: ${item.id}`);
+        }
+        const itemRoots = readRoots.map(root => within(root, item.path));
+        let metaTier;
+        for (const root of itemRoots) {
+          try {
+            const meta = JSON.parse(await readFile(path.join(root, 'meta.json'), 'utf8'));
+            if (Object.hasOwn(meta, 'tier') || Object.hasOwn(meta, 'price')) metaTier = assetTier(meta);
+            break;
+          } catch (error) { if (error?.code !== 'ENOENT') break; }
+        }
+        const categoryParts = item.path.replaceAll('\\', '/').split('/').filter(Boolean);
+        const category = categoryParts[0] === 'assets' && safe(categoryParts[1]) ? categoryParts[1] : 'pack';
+        const files = await Promise.all(item.files.map(async file => {
+          if (!file || typeof file.path !== 'string' || !file.path
+              || !Number.isInteger(file.bytes) || file.bytes < 0
+              || typeof file.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(file.sha256)) {
+            throw new Error(`導入済み素材索引の files[] が不正です: ${item.id}`);
+          }
+          const candidates = itemRoots.map(root => within(root, file.path));
+          let localPath = candidates[0];
+          for (const candidate of candidates) {
+            if (await stat(candidate).then(() => true, () => false)) { localPath = candidate; break; }
+          }
+          return { name: file.path, local_path: localPath, sha256: file.sha256, bytes: file.bytes };
+        }));
+        byId.set(item.id, { id: item.id, title: item.title, category, version: item.version,
+          price: 0, ...((Object.hasOwn(item, 'tier') ? assetTier(item) : metaTier)
+            ? { tier: Object.hasOwn(item, 'tier') ? assetTier(item) : metaTier } : {}),
+          source: 'installed', files });
+      }
+    }
+  }
+  return [...byId.values()];
+}
+
+export async function loadCatalogForResolveAsync(ref, { env = process.env, fetchImpl = fetch, timeouts } = {}) {
+  const matches = typeof ref === 'string' && ref.includes('/')
+    ? item => `${item.category}/${item.id}` === ref : item => item.id === ref;
+  const installedItems = await installedItemsAsync(env);
+  if (installedItems.some(matches)) {
+    return { schema: 'akari-assets-catalog/v0', version: null, base: null, items: installedItems };
+  }
+  if (resolveCatalogSource(env).kind === 'url') {
+    const cached = await readCatalogCache(env);
+    if (cached && cached.items.some(matches)) return mergeInstalledItems(cached, installedItems);
+  }
+  const catalog = await loadCatalog({ env, fetchImpl, timeouts, fallbackToCache: false, includeInstalled: false });
+  return mergeInstalledItems(catalog, installedItems);
+}

package/vendor/packages/asset-resolver/src/resolve.mjs

@@ -11,19 +11,18 @@ import { resolveAssetLibraryRoots } from '../../creator-root/src/index.mjs';
 // なら resolvePaidZip() が `/api/store/v1/download/<id>` から zip を取得し、展開 →
 // checksums.txt 検証（paid-zip.mjs）→ 同じ validate-asset / 原子的 move の経路に合流する。
 
-import { spawnSync } from 'node:child_process';
-import { constants, existsSync, realpathSync } from 'node:fs';
-import { cp, mkdir, mkdtemp, rename, rm } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { constants } from 'node:fs';
+import { cp, mkdir, mkdtemp, readFile, rename, rm, realpath, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { format } from 'node:util';
-import { loadCatalogForResolve } from './catalog.mjs';
+import { loadCatalogForResolveAsync, cachedAssetDirAsync } from './resolve-async-library.mjs';
 import { resolveEffectiveBase } from './env.mjs';
 import { AssetResolverError } from './errors.mjs';
 import { fetchEntitlements, readStoreCredentials } from './entitlements.mjs';
 import { materialize, resolveFileLocation } from './fetch-file.mjs';
 import { sha256File } from './hash.mjs';
-import { cachedAssetDir, localAssetDir } from './library.mjs';
 import { downloadPaidZip, extractZip, verifyPaidZipContents } from './paid-zip.mjs';
 import { recordProjectReference } from './project-references.mjs';
 import { assetTier, isAssetEntitled } from './tier.mjs';
@@ -81,7 +80,15 @@ async function validateAsset(assetDir) {
     return await run;
   } catch {
     // Module loading failures are outside the validator's ordinary NG result.
-    return spawnSync(process.execPath, [VALIDATE_ASSET_SCRIPT, assetDir], { encoding: 'utf8' });
+    return new Promise((resolveResult, reject) => {
+      const child = spawn(process.execPath, [VALIDATE_ASSET_SCRIPT, assetDir]);
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', chunk => { stdout += chunk; });
+      child.stderr.on('data', chunk => { stderr += chunk; });
+      child.on('error', reject);
+      child.on('close', status => resolveResult({ status, stdout, stderr }));
+    });
   }
 }
 
@@ -110,7 +117,7 @@ export async function copyIntoProject(sourceDir, projectDir, category, id) {
   // 素材箱側が「meta.json を含むディレクトリ = 1 カード」でグルーピングする際、
   // 深さではなくディレクトリ形で判定するため、置き場の形をライブラリと合わせておく必要はないが、
   // カテゴリ別に整理された配置の方が人間が見ても分かりやすいのでライブラリ型に統一する。
-  const realSourceDir = realpathSync(sourceDir);
+  const realSourceDir = await realpath(sourceDir);
   const dest = path.join(path.resolve(projectDir), 'assets', category, id);
   await mkdir(path.dirname(dest), { recursive: true });
   await rm(dest, { recursive: true, force: true });
@@ -119,8 +126,12 @@ export async function copyIntoProject(sourceDir, projectDir, category, id) {
     // このマシンの Node（libuv）は clonefileat 相当が ENOSYS を返し、fs.cp の
     // COPYFILE_FICLONE では節約が効かない（前段 2026-08-09-project-copy-cow-clone で実測確認済み）。
     // BSD cp -c は clonefile(2) を Node を介さず直接使うため、同じ OS/FS 上で実際にクローンできる。
-    const clone = spawnSync('/bin/cp', ['-Rc', realSourceDir, dest], { stdio: 'ignore' });
-    if (!clone.error && clone.status === 0) {
+    const cloned = await new Promise(resolveResult => {
+      const child = spawn('/bin/cp', ['-Rc', realSourceDir, dest], { stdio: 'ignore' });
+      child.on('error', () => resolveResult(false));
+      child.on('close', code => resolveResult(code === 0));
+    });
+    if (cloned) {
       return dest;
     }
     // クロスボリューム等で -c が失敗したケース。部分的に書かれた dest を掃除してから
@@ -136,7 +147,7 @@ export async function copyIntoProject(sourceDir, projectDir, category, id) {
 
 async function moveIntoLibrary(tempDir, destDir) {
   await mkdir(path.dirname(destDir), { recursive: true });
-  if (existsSync(destDir)) {
+  if (await stat(destDir).then(() => true, error => { if (error.code === 'ENOENT') return false; throw error; })) {
     await rm(destDir, { recursive: true, force: true });
   }
   try {
@@ -152,6 +163,19 @@ async function moveIntoLibrary(tempDir, destDir) {
   }
 }
 
+async function backfillLegacyMetaTier(metaPath, item) {
+  let meta;
+  try {
+    meta = JSON.parse(await readFile(metaPath, 'utf8'));
+  } catch {
+    return;
+  }
+  if (!meta || typeof meta !== 'object' || Array.isArray(meta) || Object.hasOwn(meta, 'tier')) return;
+  // R2 に公開済みの旧 meta.json（tier 導入前・price のみ）を、sha256 検証済みのうえでカタログの tier で補う互換経路。R2 の meta.json を tier 付きで上げ直したら外せる。
+  meta.tier = assetTier(item);
+  await writeFile(metaPath, `${JSON.stringify(meta, null, 2)}\n`);
+}
+
 /**
  * @param {string} ref カタログの category/id。bare id は一意な場合のみ互換解決する
  * @param {{ env?: object, fetchImpl?: Function, project?: string|null, force?: boolean, reference?: boolean }} options
@@ -161,16 +185,16 @@ export async function resolve(
   { env = process.env, fetchImpl = fetch, project = null, force = false, reference = false, timeouts } = {},
 ) {
   const home = resolveAssetLibraryRoots(env).write;
-  const catalog = await loadCatalogForResolve(ref, { env, fetchImpl, timeouts });
+  const catalog = await loadCatalogForResolveAsync(ref, { env, fetchImpl, timeouts });
   const item = findCatalogItem(catalog, ref);
 
   const tier = assetTier(item);
   const hasFiles = Array.isArray(item.files) && item.files.length > 0;
-  const destDir = localAssetDir(env, item.category, item.id);
+  const destDir = path.join(home, item.category, item.id);
 
   // キャッシュヒット → 即返す（未購入だったとしても、一度取得済みなら手元にある実体をそのまま使う。
   // ゲートは「新規に取得するとき」だけにかける）
-  const cachedDir = cachedAssetDir(env, item.category, item.id);
+  const cachedDir = await cachedAssetDirAsync(env, item.category, item.id);
   if (!force && cachedDir) {
     const result = { id: item.id, category: item.category, dir: cachedDir, cached: true };
     if (project && reference) {
@@ -244,6 +268,7 @@ export async function resolve(
 
     // still / scene3d 等、meta.json を実体に持つ素材は validate-asset で契約検証してから登録する
     if (hasMeta) {
+      await backfillLegacyMetaTier(path.join(tempAssetDir, 'meta.json'), item);
       const result = await validateAsset(tempAssetDir);
       if (result.status !== 0) {
         const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
@@ -327,6 +352,8 @@ async function resolvePaidZip(item, { env, fetchImpl, project, reference, home,
       });
     }
 
+    await backfillLegacyMetaTier(path.join(tempAssetDir, 'meta.json'), item);
+
     {
       const result = await validateAsset(tempAssetDir);
       if (result.status !== 0) {

package/vendor/packages/asset-resolver/src/shell-reference.mjs

@@ -3,19 +3,19 @@ import { lstat, readdir, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { resolveAssetLibraryRoots } from '../../creator-root/src/index.mjs';
-import { readProjectReferences, resolveLibraryFallback } from './project-references.mjs';
+import { readProjectReferences, resolveLibraryFallbackAsync } from './project-references.mjs';
 
 const within = (root, target) => {
   const rel = path.relative(root, target);
   return rel === '' || (rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel));
 };
 
-export async function resolveProjectAssetPath(project, declaredPath, env = process.env) {
+export async function resolveProjectAssetPath(project, declaredPath, env = process.env, context) {
   const normalized = declaredPath.replaceAll('\\', '/');
   if (path.isAbsolute(normalized) || normalized.split('/').some(part => part === '..' || part === '.')) {
     throw new Error('素材パスがプロジェクトの外を指しています');
   }
-  const root = await realpath(project);
+  const root = context?.projectRoot ?? await realpath(project);
   const local = path.resolve(root, normalized);
   if (!within(root, local)) throw new Error('素材パスがプロジェクトの外を指しています');
   // An existing local entry always wins, including a broken or escaping symlink:
@@ -35,34 +35,44 @@ export async function resolveProjectAssetPath(project, declaredPath, env = proce
     if (!within(root, actual)) throw new Error('素材パスがプロジェクトの外を指しています');
     return (await stat(actual)).isFile() ? actual : null;
   }
-  const references = await readProjectReferences(root);
-  for (const akariAssetsDir of resolveAssetLibraryRoots(env).read) {
-    const found = resolveLibraryFallback({ declaredPath: normalized, references, akariAssetsDir });
+  const references = context?.references ?? await readProjectReferences(root);
+  for (const akariAssetsDir of (context?.libraryRoots ?? resolveAssetLibraryRoots(env).read)) {
+    const found = await resolveLibraryFallbackAsync({ declaredPath: normalized, references, akariAssetsDir,
+      rootRealpaths: context?.rootRealpaths });
     if (found) return found;
   }
   return null;
 }
 
 /** Enumerate only ledger-authorized files, in library read order; no symlink traversal. */
-export async function listProjectReferenceAssets(project, env = process.env) {
-  const references = await readProjectReferences(project);
+export async function listProjectReferenceAssets(project, env = process.env, context) {
+  const references = context?.references ?? await readProjectReferences(project);
+  const libraryRoots = context?.libraryRoots ?? resolveAssetLibraryRoots(env).read;
+  const rootRealpaths = context?.rootRealpaths ?? new Map();
   return Promise.all(references.map(async reference => {
     const files = new Map();
     let libraryDir;
     if ([reference.category, reference.id].some(value => !value || value === '.' || value === '..' || /[\\/]/.test(value))) {
       return { ...reference, files: [] };
     }
-    for (const root of resolveAssetLibraryRoots(env).read) {
+    for (const root of libraryRoots) {
       const directory = path.resolve(root, reference.category, reference.id);
       if (!within(path.resolve(root), directory)) continue;
-      try { if (!within(await realpath(root), await realpath(directory))) continue; } catch { continue; }
+      const lexicalRoot = path.resolve(root);
+      let actualRoot = rootRealpaths.get(lexicalRoot);
+      if (!actualRoot) {
+        actualRoot = realpath(lexicalRoot);
+        rootRealpaths.set(lexicalRoot, actualRoot);
+      }
+      try { if (!within(await actualRoot, await realpath(directory))) continue; } catch { continue; }
       const walk = async (dir, prefix = '') => {
         for (const entry of await readdir(dir, { withFileTypes: true })) {
           const name = prefix + entry.name;
           if (entry.isDirectory()) await walk(path.join(dir, entry.name), `${name}/`);
           else {
-            const absolute = resolveLibraryFallback({
+            const absolute = await resolveLibraryFallbackAsync({
               declaredPath: `assets/${reference.category}/${reference.id}/${name}`, references, akariAssetsDir: root,
+              rootRealpaths,
             });
             if (absolute && !files.has(name)) {
               libraryDir ??= directory;
@@ -81,11 +91,14 @@ export async function listProjectReferenceAssets(project, env = process.env) {
 export async function projectReferenceMediaUris(project, env = process.env, declaredPaths = []) {
   const uris = {};
   const paths = new Set(declaredPaths);
-  for (const asset of await listProjectReferenceAssets(project, env)) {
+  const context = { projectRoot: await realpath(project), references: await readProjectReferences(project),
+    libraryRoots: resolveAssetLibraryRoots(env).read, rootRealpaths: new Map() };
+  for (const asset of await listProjectReferenceAssets(project, env, context)) {
     for (const file of asset.files) paths.add(`assets/${asset.category}/${asset.id}/${file.name}`);
   }
-  for (const declared of paths) {
-    const actual = await resolveProjectAssetPath(project, declared, env);
+  const resolved = await Promise.all([...paths].map(async declared =>
+    [declared, await resolveProjectAssetPath(project, declared, env, context)]));
+  for (const [declared, actual] of resolved) {
     if (actual) uris[declared.replaceAll('\\', '/')] = pathToFileURL(actual).href;
   }
   return uris;

package/vendor/packages/asset-resolver/test/library-fetch-no-spawn-reference.test.mjs

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { syncBuiltinESMExports } from 'node:module';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import test from 'node:test';
+import { listProjectReferenceAssets, projectReferenceMediaUris } from '../src/shell-reference.mjs';
+
+const names = ['realpathSync', 'lstatSync', 'statSync', 'readFileSync', 'readdirSync', 'existsSync'];
+
+async function fixture(t) {
+  const root = await mkdtemp(path.join(tmpdir(), 'reference-async-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const project = path.join(root, 'project');
+  const library = path.join(root, 'library');
+  await mkdir(path.join(project, '.akari'), { recursive: true });
+  await mkdir(path.join(library, 'still', 'sample'), { recursive: true });
+  await writeFile(path.join(project, '.akari', 'asset-references.json'),
+    JSON.stringify({ version: 0, references: [{ category: 'still', id: 'sample' }] }));
+  const env = { ...process.env, AKARI_HOME: path.join(root, 'home'),
+    AKARI_CREATOR_ROOT: path.join(root, 'creator'), AKARI_LIBRARY_ROOT: library };
+  return { project, library, env };
+}
+
+test('参照 URI と列挙は素材数に応じた同期 I/O を行わない', async t => {
+  const f = await fixture(t);
+  const originals = Object.fromEntries(names.map(name => [name, fs[name]]));
+  let direct = 0;
+  let total = 0;
+  for (const name of names) {
+    fs[name] = (...args) => {
+      total++;
+      const caller = (new Error().stack ?? '').split('\n')[2] ?? '';
+      if (/asset-resolver[/\\]src[/\\](shell-reference|project-references)\.mjs/.test(caller)) direct++;
+      return originals[name](...args);
+    };
+  }
+  syncBuiltinESMExports();
+  t.after(() => {
+    for (const name of names) fs[name] = originals[name];
+    syncBuiltinESMExports();
+  });
+  const counts = [];
+  for (const size of [3, 30]) {
+    const dir = path.join(f.library, 'still', 'sample');
+    for (let n = 0; n < size; n++) await writeFile(path.join(dir, `frame-${n}.png`), 'image');
+    const before = total;
+    const entries = await listProjectReferenceAssets(f.project, f.env);
+    const uris = await projectReferenceMediaUris(f.project, f.env);
+    counts.push(total - before);
+    assert.equal(entries[0].files.length, size);
+    assert.deepEqual(new Set(Object.keys(uris)), new Set(Array.from({ length: size }, (_, n) =>
+      `assets/still/sample/frame-${n}.png`)));
+    assert.equal(uris['assets/still/sample/frame-0.png'],
+      pathToFileURL(path.join(dir, 'frame-0.png')).href);
+  }
+  assert.equal(direct, 0);
+  assert.equal(counts[1], counts[0]);
+});

package/vendor/packages/asset-resolver/test/resolve-legacy-meta-tier.test.mjs

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { resolve as resolveAsset } from '../src/resolve.mjs';
+import { setupFixtureEnv } from './helpers.mjs';
+
+function sha256(buffer) {
+  return createHash('sha256').update(buffer).digest('hex');
+}
+
+function serveMeta({ id = 'mini-still', tier, catalogTier = 'free', omitCatalogTier = false } = {}) {
+  const fixture = setupFixtureEnv();
+  const item = fixture.catalog.items.find(entry => entry.id === id);
+  const file = item.files.find(entry => entry.name === 'meta.json');
+  const servedMeta = JSON.parse(readFileSync(path.join(fixture.baseDir, file.key), 'utf8'));
+  delete servedMeta.tier;
+  if (tier !== undefined) servedMeta.tier = tier;
+  const bytes = Buffer.from(`${JSON.stringify(servedMeta, null, 2)}\n`);
+  writeFileSync(path.join(fixture.baseDir, file.key), bytes);
+  file.sha256 = sha256(bytes);
+  file.bytes = bytes.length;
+  if (omitCatalogTier) delete item.tier;
+  else item.tier = catalogTier;
+  writeFileSync(fixture.catalogPath, `${JSON.stringify(fixture.catalog, null, 2)}\n`);
+  return { ...fixture, bytes };
+}
+
+test('resolve: sha256 検証済みの旧 free meta.json に catalog tier を補完する', async () => {
+  const { env, home } = serveMeta({ catalogTier: 'free' });
+  const result = await resolveAsset('mini-still', { env });
+
+  assert.equal(result.cached, false);
+  assert.equal(JSON.parse(readFileSync(path.join(result.dir, 'meta.json'), 'utf8')).tier, 'free');
+  assert.deepEqual(readdirSync(home).filter(name => name.startsWith('.tmp-resolve-')), []);
+});
+
+test('resolve: catalog に tier がなく price: 0 の旧 meta.json は free として解決する', async () => {
+  const { env } = serveMeta({ omitCatalogTier: true });
+  const result = await resolveAsset('mini-still', { env });
+  assert.equal(result.cached, false);
+  assert.equal(JSON.parse(readFileSync(path.join(result.dir, 'meta.json'), 'utf8')).tier, 'free');
+});
+
+test('resolve: meta.json に tier がある場合は配信バイト列を保持する', async () => {
+  const { env, bytes } = serveMeta({ tier: 'free', catalogTier: 'free' });
+  const result = await resolveAsset('mini-still', { env });
+  assert.equal(result.cached, false);
+  assert.equal(readFileSync(path.join(result.dir, 'meta.json'), 'utf8'), bytes.toString('utf8'));
+  assert.equal(existsSync(path.join(result.dir, 'meta.json')), true);
+});

package/vendor/packages/edit-store/lib/shape-markup-v1.js

@@ -75,15 +75,7 @@ function cap(kind, filled, x, y, direction, size, color, sw, minimumOutline) {
     const ow = Math.max(minimumOutline, sw * .7);
     const outline = `fill="${filled ? color : 'none'}" stroke="${color}" stroke-width="${num(ow)}"`;
     if (kind === 'triangle') {
-        let tipInset = 0;
-        if (!filled) {
-            tipInset = ow * Math.sqrt(1.25);
-            for (let i = 0; i < 12; i++) {
-                tipInset = ow * Math.hypot(size - tipInset, h) / (2 * h);
-            }
-        }
-        const tip = x - direction * tipInset;
-        return `<polygon points="${num(tip)},${num(y)} ${num(x - direction * size)},${num(y - h)} ${num(x - direction * size)},${num(y + h)}" ${filled ? `fill="${color}"` : outline}/>`;
+        return `<polygon points="${num(x)},${num(y)} ${num(x - direction * size)},${num(y - h)} ${num(x - direction * size)},${num(y + h)}" fill="${color}"/>`;
     }
     if (kind === 'chevron') {
         // Account for the miter at the tip and the stroke at the two roots.
@@ -112,6 +104,12 @@ function capInset(kind, size, strokeWidth) {
         return strokeWidth / 2;
     if (kind === 'chevron')
         return chevronGeometry(size, strokeWidth).miter;
+    if (kind === 'diamond')
+        return size - Math.min(strokeWidth / 2, size / 2);
+    if (kind === 'circle') {
+        const radius = size / 2;
+        return radius + Math.sqrt(Math.max(0, radius * radius - (strokeWidth / 2) ** 2));
+    }
     return size;
 }
 function strokeMetrics(visibleWidth, scaleX, scaleY) {
@@ -119,7 +117,7 @@ function strokeMetrics(visibleWidth, scaleX, scaleY) {
     return {
         width: visibleWidth / correction,
         gap: Math.max(visibleWidth * 2, 3) / correction,
-        capSize: Math.max(visibleWidth * 2.5, 8) / correction,
+        capSize: Math.max(visibleWidth * 3.75, 12) / correction,
         minimumOutline: 1 / correction,
     };
 }
@@ -142,10 +140,16 @@ function lineBody(p, width, height, metrics, color, visibleStrokeWidth, scaleX,
     const rounded = p.lineCap === 'round' && dash !== 'dot';
     const dashAttr = dashAttribute(dash, metrics, rounded);
     const stretched = scaleX !== scaleY;
-    const capSize = stretched ? Math.max(visibleStrokeWidth * 2.5, 8) : size;
-    const startSize = capSize * clamp(p.startCapScale, 1, .5, 3);
-    const endSize = capSize * clamp(p.endCapScale, 1, .5, 3);
+    const capSize = stretched ? Math.max(visibleStrokeWidth * 3.75, 12) : size;
     const capStroke = stretched ? visibleStrokeWidth : sw;
+    // At the smallest slider value the open arms must remain longer than 3w.
+    // A 4w envelope gives a centerline arm of about 3.16w.
+    const effectiveSize = (kind, scale) => {
+        const scaled = capSize * clamp(scale, 1, .5, 3);
+        return kind === 'chevron' ? Math.max(scaled, capStroke * 4) : scaled;
+    };
+    const startSize = effectiveSize(start, p.startCapScale);
+    const endSize = effectiveSize(end, p.endCapScale);
     const inset = (kind, capLength) => capInset(kind, capLength, capStroke) / (stretched ? scaleX : 1);
     const extension = rounded ? sw / 2 : 0;
     const x1 = inset(start, startSize) + extension;

package/vendor/packages/edit-store/lib/webview-kernel.js

@@ -4035,15 +4035,7 @@ var AkariEditKernel = (() => {
     const ow = Math.max(minimumOutline, sw * 0.7);
     const outline = `fill="${filled ? color2 : "none"}" stroke="${color2}" stroke-width="${num(ow)}"`;
     if (kind === "triangle") {
-      let tipInset = 0;
-      if (!filled) {
-        tipInset = ow * Math.sqrt(1.25);
-        for (let i = 0; i < 12; i++) {
-          tipInset = ow * Math.hypot(size - tipInset, h) / (2 * h);
-        }
-      }
-      const tip = x - direction * tipInset;
-      return `<polygon points="${num(tip)},${num(y)} ${num(x - direction * size)},${num(y - h)} ${num(x - direction * size)},${num(y + h)}" ${filled ? `fill="${color2}"` : outline}/>`;
+      return `<polygon points="${num(x)},${num(y)} ${num(x - direction * size)},${num(y - h)} ${num(x - direction * size)},${num(y + h)}" fill="${color2}"/>`;
     }
     if (kind === "chevron") {
       const { halfWidth, miter, root } = chevronGeometry(size, sw);
@@ -4067,6 +4059,11 @@ var AkariEditKernel = (() => {
     if (kind === "none") return 0;
     if (kind === "bar") return strokeWidth / 2;
     if (kind === "chevron") return chevronGeometry(size, strokeWidth).miter;
+    if (kind === "diamond") return size - Math.min(strokeWidth / 2, size / 2);
+    if (kind === "circle") {
+      const radius = size / 2;
+      return radius + Math.sqrt(Math.max(0, radius * radius - (strokeWidth / 2) ** 2));
+    }
     return size;
   }
   function strokeMetrics(visibleWidth, scaleX, scaleY) {
@@ -4074,7 +4071,7 @@ var AkariEditKernel = (() => {
     return {
       width: visibleWidth / correction,
       gap: Math.max(visibleWidth * 2, 3) / correction,
-      capSize: Math.max(visibleWidth * 2.5, 8) / correction,
+      capSize: Math.max(visibleWidth * 3.75, 12) / correction,
       minimumOutline: 1 / correction
     };
   }
@@ -4096,10 +4093,14 @@ var AkariEditKernel = (() => {
     const rounded = p.lineCap === "round" && dash !== "dot";
     const dashAttr = dashAttribute(dash, metrics, rounded);
     const stretched = scaleX !== scaleY;
-    const capSize = stretched ? Math.max(visibleStrokeWidth * 2.5, 8) : size;
-    const startSize = capSize * clamp3(p.startCapScale, 1, 0.5, 3);
-    const endSize = capSize * clamp3(p.endCapScale, 1, 0.5, 3);
+    const capSize = stretched ? Math.max(visibleStrokeWidth * 3.75, 12) : size;
     const capStroke = stretched ? visibleStrokeWidth : sw;
+    const effectiveSize = (kind, scale) => {
+      const scaled = capSize * clamp3(scale, 1, 0.5, 3);
+      return kind === "chevron" ? Math.max(scaled, capStroke * 4) : scaled;
+    };
+    const startSize = effectiveSize(start, p.startCapScale);
+    const endSize = effectiveSize(end, p.endCapScale);
     const inset = (kind, capLength) => capInset(kind, capLength, capStroke) / (stretched ? scaleX : 1);
     const extension = rounded ? sw / 2 : 0;
     const x1 = inset(start, startSize) + extension;