@tiinex/app 0.1.1

package/src/adapters/local/local.adapter.case.mjs

@@ -0,0 +1,72 @@
+import assert from 'assert';
+import { collectLocalFilesFromDataTransfer, isMarkdownLikeFileName, materializeLocalMarkdownFiles } from './local.adapter.js';
+
+const encoder = new TextEncoder();
+function localFile(name, text, webkitRelativePath = name, type = '') {
+  const bytes = encoder.encode(text);
+  return {
+    name,
+    webkitRelativePath,
+    relativePath: webkitRelativePath,
+    size: bytes.byteLength,
+    type,
+    lastModified: Date.UTC(2026, 0, 1),
+    text: async () => text,
+    arrayBuffer: async () => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+  };
+}
+
+assert(isMarkdownLikeFileName('a.md'), 'md should be recognized');
+assert(isMarkdownLikeFileName('topic.trace.md'), 'trace markdown should be recognized');
+assert(!isMarkdownLikeFileName('image.png'), 'png should not be recognized as markdown');
+
+const filesResult = await materializeLocalMarkdownFiles([
+  localFile('a.md', '# A\n\nBody', 'folder/a.md'),
+  localFile('b.png', 'binary', 'folder/b.png', 'image/png')
+]);
+assert.equal(filesResult.adapterId, 'local', 'local adapter should own local material result');
+assert.equal(filesResult.records.length, 1, 'local adapter should materialize one markdown file');
+assert.equal(filesResult.records[0].path, 'folder/a.md', 'local adapter should preserve relative paths');
+assert.equal(filesResult.assets.length, 1, 'local adapter should preserve non-markdown folder files as assets');
+assert.equal(filesResult.assets[0].path, 'folder/b.png', 'local adapter should preserve asset relative path');
+assert.equal(filesResult.warnings.length, 0, 'preserved assets should not be treated as unsupported warnings');
+
+function fileEntry(name, text) {
+  return {
+    isFile: true,
+    isDirectory: false,
+    name,
+    file(resolve) {
+      resolve(localFile(name, text, name));
+    }
+  };
+}
+function dirEntry(name, entries) {
+  return {
+    isFile: false,
+    isDirectory: true,
+    name,
+    createReader() {
+      let done = false;
+      return {
+        readEntries(resolve) {
+          if (done) return resolve([]);
+          done = true;
+          resolve(entries);
+        }
+      };
+    }
+  };
+}
+const dropped = await collectLocalFilesFromDataTransfer({
+  items: [
+    { webkitGetAsEntry: () => dirEntry('root', [fileEntry('one.md', '# One'), dirEntry('nested', [fileEntry('two.trace.md', '# Two')])]) }
+  ],
+  files: []
+});
+assert.equal(dropped.length, 2, 'directory drop should recursively collect files');
+assert(dropped.some((file) => file.webkitRelativePath === 'root/one.md'), 'root file path should be preserved');
+assert(dropped.some((file) => file.webkitRelativePath === 'root/nested/two.trace.md'), 'nested file path should be preserved');
+assert.equal(typeof dropped[0].arrayBuffer, 'function', 'wrapped dropped files must preserve arrayBuffer for zip/archive routing');
+
+console.log('✓ local adapter tests passed');

package/src/adapters/local/local.adapter.js

@@ -0,0 +1,188 @@
+import { AdapterAvailability, makeAdapterDefinition, makeAdapterResult } from '@tiinex/core/adapters/adapter.contracts.js';
+import { materializeArchiveFiles } from '@tiinex/core/adapters/archive/archive.adapter.js';
+
+export const LOCAL_ADAPTER_ID = 'local';
+
+export function createLocalAdapter() {
+  return makeAdapterDefinition({
+    id: LOCAL_ADAPTER_ID,
+    label: 'Local session material',
+    availability: AdapterAvailability.available,
+    sourceKinds: ['local.session', 'local.files', 'local.folder', 'local.drop', 'local.zip'],
+    capabilities: {
+      registerSource: true,
+      materialize: true,
+      openExternal: false,
+      requiresBridge: false
+    },
+    configShape: {
+      files: 'FileList | File[] supplied by browser UI; .zip routes through archive adapter',
+      folder: 'browser DataTransferEntry or webkitdirectory FileList when user grants access',
+      persistence: 'browser-local workspace state'
+    },
+    boundary: 'browser-local session material; no external provenance inferred',
+    notes: ['UI supplies File objects or a drop DataTransfer; adapter contract owns browser-local materialization boundary.']
+  });
+}
+
+export function createLocalAdapterResult(records = [], diagnostics = {}) {
+  return makeAdapterResult({
+    adapterId: LOCAL_ADAPTER_ID,
+    sourceId: 'local',
+    records,
+    diagnostics: Object.assign({ sourceBoundary: 'local-session' }, diagnostics)
+  });
+}
+
+const MARKDOWN_FILE_RE = /(?:\.md|\.markdown|\.trace\.md|\.schema\.md|\.workspace\.md)$/i;
+const SUPPORTED_LOCAL_FILE_RE = /(?:\.md|\.markdown|\.trace\.md|\.schema\.md|\.validator\.md|\.workspace\.md|\.zip)$/i;
+
+export function isMarkdownLikeFileName(name = '') {
+  return MARKDOWN_FILE_RE.test(String(name || '').trim());
+}
+
+export function isSupportedLocalIntakeFileName(name = '') {
+  return SUPPORTED_LOCAL_FILE_RE.test(String(name || '').trim());
+}
+
+export async function collectLocalFilesFromDataTransfer(dataTransfer) {
+  if (!dataTransfer) return [];
+  const items = Array.from(dataTransfer.items || []).filter(Boolean);
+  if (!items.length) return Array.from(dataTransfer.files || []).filter(Boolean);
+  const collected = [];
+  for (const item of items) {
+    if (typeof item.getAsFileSystemHandle === 'function') {
+      try {
+        const handle = await item.getAsFileSystemHandle();
+        if (handle) {
+          collected.push(...await readFileSystemHandleFiles(handle));
+          continue;
+        }
+      } catch (_) {}
+    }
+    const entry = typeof item.webkitGetAsEntry === 'function' ? item.webkitGetAsEntry() : null;
+    if (entry) {
+      collected.push(...await readEntryFiles(entry));
+      continue;
+    }
+    const file = typeof item.getAsFile === 'function' ? item.getAsFile() : null;
+    if (file) collected.push(file);
+  }
+  return collected.length ? collected : Array.from(dataTransfer.files || []).filter(Boolean);
+}
+
+async function readFileSystemHandleFiles(handle, parentPath = '') {
+  if (!handle) return [];
+  const currentPath = [parentPath, handle.name || 'file'].filter(Boolean).join('/');
+  if (handle.kind === 'file') {
+    try {
+      const file = await handle.getFile();
+      return [wrapFileWithRelativePath(file, currentPath)];
+    } catch (_) {
+      return [];
+    }
+  }
+  if (handle.kind !== 'directory') return [];
+  const nested = [];
+  try {
+    for await (const child of handle.values()) nested.push(...await readFileSystemHandleFiles(child, currentPath));
+  } catch (_) {}
+  return nested;
+}
+
+async function readEntryFiles(entry, parentPath = '') {
+  if (!entry) return [];
+  if (entry.isFile) {
+    const file = await entryFile(entry);
+    const relativePath = [parentPath, entry.name || file?.name || 'file'].filter(Boolean).join('/');
+    return [wrapFileWithRelativePath(file, relativePath)];
+  }
+  if (!entry.isDirectory) return [];
+  const reader = entry.createReader?.();
+  if (!reader) return [];
+  const folderPath = [parentPath, entry.name || 'folder'].filter(Boolean).join('/');
+  const entries = await readAllDirectoryEntries(reader);
+  const nested = [];
+  for (const child of entries) nested.push(...await readEntryFiles(child, folderPath));
+  return nested;
+}
+
+function entryFile(entry) {
+  return new Promise((resolve, reject) => {
+    try {
+      entry.file(resolve, reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function readAllDirectoryEntries(reader) {
+  return new Promise((resolve, reject) => {
+    const all = [];
+    const read = () => {
+      try {
+        reader.readEntries((entries = []) => {
+          if (!entries.length) return resolve(all);
+          all.push(...entries);
+          read();
+        }, reject);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    read();
+  });
+}
+
+function wrapFileWithRelativePath(file, relativePath) {
+  if (!file) return file;
+  const path = relativePath || file.webkitRelativePath || file.name || 'file';
+  return {
+    name: file.name || path.split('/').pop() || 'file',
+    size: file.size,
+    type: file.type,
+    lastModified: file.lastModified,
+    relativePath: path,
+    webkitRelativePath: path,
+    tiinexRelativePath: path,
+    text: () => file.text(),
+    arrayBuffer: () => file.arrayBuffer(),
+    stream: typeof file.stream === 'function' ? () => file.stream() : undefined,
+    slice: typeof file.slice === 'function' ? (...args) => file.slice(...args) : undefined
+  };
+}
+
+export async function materializeLocalMarkdownFiles(fileList = [], options = {}) {
+  const files = Array.from(fileList || []).filter(Boolean);
+  if (!files.length) {
+    return makeAdapterResult({
+      adapterId: LOCAL_ADAPTER_ID,
+      sourceId: 'local',
+      records: [],
+      assets: [],
+      workspaceEntries: [],
+      diagnostics: { sourceBoundary: 'local-session', fileCount: 0, skippedCount: 0 }
+    });
+  }
+
+  // Delegate all browser-local files/folders/zips through the archive intake contract.
+  // This preserves the PoC behavior where folders may contain a mix of leaves, workspace files,
+  // and assets. UI must not decide that non-Markdown files are disposable.
+  const result = await materializeArchiveFiles(files, {
+    ...options,
+    sourceMode: options.sourceMode || 'local-files',
+    source: options.sourceMode || 'local-files'
+  });
+  return makeAdapterResult({
+    adapterId: LOCAL_ADAPTER_ID,
+    sourceId: 'local',
+    state: result.state,
+    records: result.records,
+    assets: result.assets,
+    workspaceEntries: result.workspaceEntries,
+    errors: result.errors,
+    warnings: result.warnings,
+    diagnostics: Object.assign({ sourceBoundary: 'local-session', fileCount: files.length }, result.diagnostics || {})
+  });
+}

package/src/adapters/registry.js

@@ -0,0 +1,35 @@
+import { createArchiveAdapter } from '@tiinex/core/adapters/archive/archive.adapter.js';
+import { createExportAdapter } from './export/export.adapter.js';
+import { createGitNativeAdapter } from './git-native/git-native.adapter.js';
+import { createGithubAdapter } from './github/github.adapter.js';
+import { createLocalAdapter } from './local/local.adapter.js';
+import { createStaticAdapter } from './static/static.adapter.js';
+
+export function createAdapterRegistry(extraAdapters = []) {
+  const adapters = [
+    createLocalAdapter(),
+    createArchiveAdapter(),
+    createGithubAdapter(),
+    createStaticAdapter(),
+    createGitNativeAdapter(),
+    createExportAdapter(),
+    ...extraAdapters
+  ];
+  const byId = new Map();
+  const bySourceKind = new Map();
+  for (const adapter of adapters) {
+    if (!adapter?.id) continue;
+    byId.set(adapter.id, adapter);
+    for (const sourceKind of adapter.sourceKinds || []) bySourceKind.set(sourceKind, adapter);
+  }
+  return Object.freeze({
+    adapters: Object.freeze(Array.from(byId.values())),
+    byId: Object.freeze(Object.fromEntries(byId.entries())),
+    bySourceKind: Object.freeze(Object.fromEntries(bySourceKind.entries())),
+    get(id) { return byId.get(String(id || '').trim().toLowerCase()) || null; },
+    forSourceKind(sourceKind) { return bySourceKind.get(String(sourceKind || '').trim()) || null; },
+    listSourceKinds() { return Object.freeze(Array.from(bySourceKind.keys()).sort()); }
+  });
+}
+
+export const TiinexAdapterRegistry = createAdapterRegistry();

package/src/adapters/static/static.adapter.js

@@ -0,0 +1,84 @@
+import { AdapterAvailability, makeAdapterDefinition, makeAdapterResult } from '@tiinex/core/adapters/adapter.contracts.js';
+import { createRecordFromMarkdown } from '@tiinex/core/artifacts/artifact.record.js';
+import { explicitWebArtifactSourceTarget, normalizeExternalWebArtifactUrl } from '@tiinex/core/sources/source.explicitTargets.js';
+
+export const STATIC_ADAPTER_ID = 'static';
+
+export function createStaticAdapter() {
+  return makeAdapterDefinition({
+    id: STATIC_ADAPTER_ID,
+    label: 'Static bundle',
+    availability: AdapterAvailability.available,
+    sourceKinds: ['static.fixture', 'static.public-build'],
+    capabilities: {
+      registerSource: true,
+      materialize: true,
+      openExternal: false,
+      requiresBridge: false
+    },
+    configShape: {
+      path: 'bundled/public path',
+      buildId: 'optional public build id'
+    },
+    boundary: 'static bundled material; provenance must be declared by the bundle',
+    notes: ['Static adapter describes packaged material; it does not guess GitHub origin.']
+  });
+}
+
+export function createStaticAdapterResult(records = [], diagnostics = {}) {
+  return makeAdapterResult({ adapterId: STATIC_ADAPTER_ID, records, diagnostics });
+}
+
+
+function normalizeReadableUrl(value) {
+  const raw = String(value || '').trim();
+  const url = new URL(raw);
+  if (!/^https?:$/i.test(url.protocol)) throw new Error('non-http(s) URL');
+  if (url.hostname === 'github.com' && url.pathname.includes('/blob/')) {
+    const [owner, repo, , ref, ...path] = url.pathname.split('/').filter(Boolean);
+    if (!owner || !repo || !ref || !path.length) throw new Error('invalid github blob URL');
+    return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path.join('/')}`;
+  }
+  return url.href;
+}
+
+function fileNameFromUrl(value) {
+  try {
+    return new URL(value).pathname.split('/').filter(Boolean).pop() || value;
+  } catch {
+    return value;
+  }
+}
+
+export async function materializeExplicitUrls(urls = [], options = {}) {
+  const fetchImpl = options.fetchImpl || (typeof fetch !== 'undefined' ? fetch : null);
+  if (!fetchImpl) throw new Error('fetchImpl not available');
+  const refs = (Array.isArray(urls) ? urls : String(urls || '').split(/\r?\n/)).map((line) => String(line || '').trim()).filter(Boolean);
+  const records = [];
+  const errors = [];
+  const seenTargets = new Set();
+  let duplicateCount = 0;
+  for (const ref of refs) {
+    let fetchUrl;
+    try {
+      const inputTarget = normalizeExternalWebArtifactUrl(ref);
+      if (!inputTarget) throw new Error('non-http(s) URL');
+      if (seenTargets.has(inputTarget)) { duplicateCount += 1; continue; }
+      seenTargets.add(inputTarget);
+      fetchUrl = normalizeReadableUrl(inputTarget);
+      const response = await fetchImpl(fetchUrl, { cache: 'no-store' });
+      if (!response || !response.ok) throw new Error(`${response?.status || 'ERR'} ${response?.statusText || ''}`.trim());
+      const markdown = await response.text();
+      const sourceTarget = explicitWebArtifactSourceTarget(inputTarget, fetchUrl);
+      records.push(Object.assign(createRecordFromMarkdown(markdown, { path: fileNameFromUrl(inputTarget), name: fileNameFromUrl(inputTarget), sourceMode: 'explicit-url' }), { sourceTarget }));
+    } catch (error) {
+      errors.push({ code: 'url.load-failed', ref, message: String(error && error.message ? error.message : error) });
+    }
+  }
+  return makeAdapterResult({
+    adapterId: STATIC_ADAPTER_ID,
+    records,
+    errors,
+    diagnostics: { transport: 'explicit-url', requestedCount: refs.length, distinctTargetCount: seenTargets.size, duplicateCount }
+  });
+}

package/src/app/App.js

@@ -0,0 +1 @@
+export { TiinexApp } from './TiinexApp.jsx';