@entrorove/skill 0.1.68 → 0.1.70

package/local-scope-uni-build.mjs

@@ -0,0 +1,135 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { uniConditionalError } from './local-scope-uni-expressions.mjs';
+
+const controls = /\bUNI_(?:CUSTOM_DEFINE|SCRIPT_(?:DEFINE|ENV)|COMPILER_VERSION|APP_X(?:_DOM2)?|UTS_PLATFORM)\b/;
+const controlKeys = ['UNI_CUSTOM_DEFINE', 'UNI_SCRIPT_DEFINE', 'UNI_SCRIPT_ENV', 'UNI_COMPILER_VERSION', 'UNI_APP_X', 'UNI_APP_X_DOM2', 'UNI_UTS_PLATFORM'];
+const configNames = ['vite.config.js', 'vite.config.mjs', 'vite.config.cjs', 'vite.config.ts',
+  'vite.config.mts', 'vite.config.cts', 'vue.config.js', 'vue.config.cjs'];
+function staticConfiguration(source, filename, fail) {
+  if (controls.test(source)) throw fail('Custom conditional macro or compiler controls require explicit scanner support');
+  const tree = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS), imports = new Map();
+  if (tree.parseDiagnostics.length) throw fail('Conditional build configuration has invalid syntax');
+  let exported = false, nodes = 0;
+  const value = (node, depth = 0) => {
+    if (++nodes > 2048 || depth > 24) throw fail('Conditional build configuration exceeds its static inspection bound');
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) return value(node.expression, depth + 1);
+    if (ts.isStringLiteral(node) || ts.isNumericLiteral(node)
+      || [ts.SyntaxKind.TrueKeyword, ts.SyntaxKind.FalseKeyword, ts.SyntaxKind.NullKeyword].includes(node.kind)) return;
+    if (ts.isArrayLiteralExpression(node)) { for (const item of node.elements) value(item, depth + 1); return; }
+    if (ts.isObjectLiteralExpression(node)) {
+      for (const property of node.properties) {
+        if (!ts.isPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) throw fail('Dynamic build properties cannot establish default conditional macros');
+        value(property.initializer, depth + 1);
+      }
+      return;
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const operation = imports.get(node.expression.text);
+      if (operation === 'uni' && node.arguments.length === 0) return;
+      if (operation === 'defineConfig' && node.arguments.length === 1) return value(node.arguments[0], depth + 1);
+    }
+    throw fail('Dynamic build configuration cannot establish default conditional macros without execution');
+  };
+  for (const statement of tree.statements) {
+    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+      const module = statement.moduleSpecifier.text, clause = statement.importClause;
+      if (module === '@dcloudio/vite-plugin-uni' && clause?.name && !clause.namedBindings) imports.set(clause.name.text, 'uni');
+      else if (module === 'vite' && !clause?.name && clause?.namedBindings && ts.isNamedImports(clause.namedBindings)
+        && clause.namedBindings.elements.every(element => (element.propertyName ?? element.name).text === 'defineConfig')) {
+        for (const element of clause.namedBindings.elements) imports.set(element.name.text, 'defineConfig');
+      } else throw fail('Custom build imports cannot establish default conditional macros without execution');
+    } else if (ts.isExportAssignment(statement) && !exported && !statement.isExportEquals) { exported = true; value(statement.expression); }
+    else if (ts.isExpressionStatement(statement) && !exported && ts.isBinaryExpression(statement.expression)
+      && statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken
+      && statement.expression.left.getText(tree) === 'module.exports') { exported = true; value(statement.expression.right); }
+    else if (!ts.isEmptyStatement(statement)) throw fail('Custom build statements cannot establish default conditional macros without execution');
+  }
+  if (!exported) throw fail('Conditional build configuration requires a statically inspectable export');
+}
+function packageConfiguration(source, fail) {
+  let manifest;
+  try { manifest = JSON.parse(source); } catch { throw fail('Conditional build package manifest is invalid JSON'); }
+  const scripts = manifest?.['uni-app']?.scripts;
+  if (scripts !== undefined) {
+    if (!scripts || typeof scripts !== 'object' || Array.isArray(scripts)) throw fail('Custom uni-app build scripts are not statically inspectable');
+    for (const configuration of Object.values(scripts)) {
+      if (!configuration || typeof configuration !== 'object' || Array.isArray(configuration)) throw fail('Custom uni-app build entry is not statically inspectable');
+      if (configuration.define !== undefined && (!configuration.define || typeof configuration.define !== 'object'
+        || Array.isArray(configuration.define) || Object.keys(configuration.define).length)) {
+        throw fail('Custom uni-app defines, including builtin macro overrides, require explicit scanner support');
+      }
+      if (controls.test(JSON.stringify(configuration))) throw fail('Custom conditional build environment requires explicit scanner support');
+    }
+  }
+  for (const [name, command] of Object.entries(manifest?.scripts ?? {})) {
+    if (typeof command !== 'string' || controls.test(command)) throw fail('Custom conditional build command requires explicit scanner support');
+    if (/^(?:dev|build)(?::|$)/.test(name) && (!/^(?:cross-env\s+NODE_ENV=(?:development|production|test)\s+)?(?:uni|vite|vue-cli-service\s+uni-(?:build|serve))(?:\s+[A-Za-z0-9_./:@=-]+)*$/.test(command)
+      || /(?:^|\s)(?:--config(?:[=\s]|$)|-c(?:\s|$)|--define(?:[=\s]|$))/.test(command))) {
+      throw fail('Custom conditional build command requires explicit scanner support');
+    }
+  }
+}
+function parentDirectories(relative, output, fail) {
+  let directory = path.posix.dirname(relative);
+  while (true) {
+    output.add(directory);
+    if (output.size > 128) throw fail('Conditional build roots exceed their 128-directory inspection bound');
+    if (directory === '.') return;
+    directory = path.posix.dirname(directory);
+  }
+}
+function assertProcessControls(filename) {
+  const present = controlKeys.filter(key => Object.hasOwn(process.env, key) || Object.hasOwn(process, key));
+  if (present.length) throw uniConditionalError(filename, 0, `Conditional compilation override controls are unsupported: ${present.join(', ')}`);
+}
+export function createUniBuildInspection(read, inspectDirectory) {
+  const inspected = new Map(), directoriesInspected = new Set(); let candidates = 0, bytes = 0, directoryEntries = 0;
+  const inspect = async relative => {
+    if (inspected.has(relative)) return inspected.get(relative);
+    if (++candidates > 2048) throw uniConditionalError(relative, 0, 'Conditional build lookup exceeds its 2048-path bound');
+    let item;
+    try { item = await read(relative); } catch (error) { if (error.code === 'ENOENT') { inspected.set(relative, null); return null; } throw error; }
+    const source = Buffer.from(item.contentBase64, 'base64').toString('utf8'), fail = reason => uniConditionalError(relative, 0, reason);
+    bytes += Buffer.byteLength(source);
+    if (Buffer.byteLength(source) > 1_048_576 || bytes > 8_388_608) throw fail('Conditional build metadata exceeds its bounded inspection size');
+    if (relative.endsWith('package.json')) packageConfiguration(source, fail); else staticConfiguration(source, relative, fail);
+    const observed = { path: item.path, sha256: item.sha256 }; inspected.set(relative, observed); return observed;
+  };
+  const inspectSource = async (sourcePath, configPath) => {
+    const directories = new Set(), fail = reason => uniConditionalError(sourcePath, 0, reason);
+    assertProcessControls(sourcePath);
+    parentDirectories(sourcePath, directories, fail); if (configPath) parentDirectories(configPath, directories, fail);
+    const observations = new Map();
+    for (const directory of directories) {
+      if (!directoriesInspected.has(directory)) {
+        if (typeof inspectDirectory !== 'function') throw fail('Conditional build environment absence requires actual bounded directory inspection');
+        const listing = await inspectDirectory(directory, Math.min(8192, 32768 - directoryEntries));
+        directoryEntries += listing.entries;
+        if (listing.environmentFiles.length) throw fail('Conditional sources with ancestor environment files require explicit scanner support; environment values were not read');
+        directoriesInspected.add(directory);
+      }
+      for (const name of ['package.json', ...configNames]) {
+        const relative = directory === '.' ? name : `${directory}/${name}`, observed = await inspect(relative);
+        if (observed) observations.set(relative, observed);
+      }
+    }
+    return [...observations.values()];
+  };
+  inspectSource.verify = async () => {
+    if (!directoriesInspected.size) return;
+    assertProcessControls('conditional-build'); let entries = 0;
+    for (const directory of directoriesInspected) {
+      const listing = await inspectDirectory(directory, Math.min(8192, 32768 - entries)); entries += listing.entries;
+      if (listing.environmentFiles.length) throw Object.assign(uniConditionalError(directory, 0,
+        'Conditional build environment appeared after its actual inspection; environment values were not read'), { code: 'ENTROROVE_SCOPE_CHANGED' });
+    }
+    for (const [relative, expected] of inspected) {
+      let actual;
+      try { actual = await read(relative); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+      if ((actual?.sha256 ?? null) !== (expected?.sha256 ?? null)) throw Object.assign(
+        uniConditionalError(relative, 0, 'Conditional build metadata changed during inspection'), { code: 'ENTROROVE_SCOPE_CHANGED' });
+    }
+  };
+  return inspectSource;
+}

package/local-scope-uni-conditional.mjs

@@ -0,0 +1,54 @@
+import { uniDirectives } from './local-scope-uni-directives.mjs';
+import { uniCondition, uniConditionContexts, uniConditionalError } from './local-scope-uni-expressions.mjs';
+
+const blank = source => source.replace(/[^\r\n]/g, ' ');
+function conditionalSegments(source, directives, filename) {
+  const stack = [], segments = [], conditions = []; let cursor = 0, conditionTokens = 0;
+  for (const item of directives) {
+    segments.push({ start: cursor, end: item.start, guards: stack.map(guard => ({ ...guard })) });
+    segments.push({ start: item.start, end: item.end, directive: true }); cursor = item.end;
+    const fail = reason => uniConditionalError(filename, item.start, reason, source);
+    if (['ifdef', 'ifndef', 'if'].includes(item.kind)) {
+      if (stack.length >= 32) throw fail('Conditional compilation exceeds its 32-level nesting bound');
+      const condition = uniCondition(item.expression, fail), index = conditions.length;
+      if ((conditionTokens += condition.tokens) > 4096) throw fail('Conditional expressions exceed their 4096-token aggregate inspection bound');
+      conditions.push(condition); stack.push({ index, negated: item.kind === 'ifndef', syntax: item.syntax, alternative: false });
+    } else {
+      const active = stack.at(-1);
+      if (!active || active.syntax !== item.syntax) throw fail('Conditional directive has no matching opening in the same source language');
+      if (item.kind === 'else') {
+        if (active.alternative) throw fail('Conditional block has more than one alternative');
+        active.negated = !active.negated; active.alternative = true;
+      } else stack.pop();
+    }
+  }
+  if (stack.length) throw uniConditionalError(filename, directives.at(-1).start, 'Conditional block is missing its matching endif', source);
+  segments.push({ start: cursor, end: source.length, guards: [] });
+  return { conditions, segments };
+}
+const activeSegment = (segment, key) => !segment.directive && segment.guards.every(guard => (key[guard.index] === '1') !== guard.negated);
+export function uniConditionalVariants(source, filename) {
+  const fail = reason => uniConditionalError(filename, 0, reason, source);
+  if (typeof source !== 'string') throw fail('Conditional inspection requires actual source text');
+  const unchanged = () => ({ directives: [], variants: [{ source, key: '', label: 'unconditional' }] });
+  if (!/(?:<!--|\/\/|\/\*)[ \t]*#/i.test(source)) return unchanged();
+  if (Buffer.byteLength(source) > 2_097_152) throw fail('Conditional source exceeds its 2 MiB inspection bound');
+  try {
+    const directives = uniDirectives(source, filename);
+    if (!directives.length) return unchanged();
+    const { conditions, segments } = conditionalSegments(source, directives, filename), contexts = uniConditionContexts(conditions, fail);
+    if (Buffer.byteLength(source) * contexts.length > 33_554_432) throw fail('Conditional source variants exceed their 32 MiB inspection bound');
+    for (const segment of segments) if (!segment.directive && source.slice(segment.start, segment.end).trim()
+      && !contexts.some(context => activeSegment(segment, context.key))) {
+      throw uniConditionalError(filename, segment.start, 'Conditional branch has no proven platform context; custom or contradictory build definitions require explicit support', source);
+    }
+    const variants = contexts.map(context => ({ key: context.key, label: context.label,
+      source: segments.map(segment => {
+        const text = source.slice(segment.start, segment.end); return activeSegment(segment, context.key) ? text : blank(text);
+      }).join('') }));
+    return { directives: directives.map(({ kind, expression, syntax }) => ({ kind, expression, syntax })), variants };
+  } catch (error) {
+    if (error instanceof RangeError) throw Object.assign(fail('Conditional syntax exceeds its parser or traversal bound'), { code: 'ENTROROVE_SCOPE_LIMIT' });
+    throw error;
+  }
+}

package/local-scope-uni-directives.mjs

@@ -0,0 +1,96 @@
+import ts from 'typescript';
+import { uniConditionalError } from './local-scope-uni-expressions.mjs';
+
+function directive(source, start, end, text, syntax, filename, output) {
+  const match = /^\s*#([a-z]+)\b([\s\S]*)$/i.exec(text);
+  if (!match) return;
+  const kind = match[1].toLowerCase(), expression = match[2].trim();
+  if (!['ifdef', 'ifndef', 'if', 'else', 'endif', 'elif', 'elseif', 'exec', 'include', 'define', 'exclude', 'endexclude'].includes(kind)) return;
+  if (!['ifdef', 'ifndef', 'if', 'else', 'endif'].includes(kind) || /[\r\n]/.test(expression)
+    || ['else', 'endif'].includes(kind) && expression) {
+    throw uniConditionalError(filename, start, 'Conditional directive syntax is unsupported', source);
+  }
+  if (output.length >= 256) throw uniConditionalError(filename, start, 'Conditional directives exceed their 256-entry bound', source);
+  output.push({ start, end, kind, expression, syntax });
+}
+function literalRanges(content, kind) {
+  const parsed = ts.createSourceFile('uni-script.ts', content, ts.ScriptTarget.Latest, true, kind);
+  const pending = [parsed], ranges = []; let nodes = 0;
+  while (pending.length) {
+    const node = pending.pop();
+    if (++nodes > 200_000) throw new RangeError('Conditional lexical inspection exceeds its node bound');
+    if (ts.isStringLiteralLike(node) || ts.isRegularExpressionLiteral(node)
+      || [ts.SyntaxKind.TemplateHead, ts.SyntaxKind.TemplateMiddle, ts.SyntaxKind.TemplateTail].includes(node.kind)) {
+      ranges.push({ start: node.getStart(parsed), end: node.end });
+    } else ts.forEachChild(node, child => { pending.push(child); });
+  }
+  return ranges.sort((a, b) => a.start - b.start);
+}
+function scriptComments(source, start, end, filename, output, kind) {
+  const content = source.slice(start, end), literals = literalRanges(content, kind); let literal = 0;
+  for (let index = 0; index < content.length;) {
+    while (literals[literal]?.end <= index) literal++;
+    if (literals[literal]?.start <= index) { index = literals[literal].end; continue; }
+    if (content.startsWith('//', index)) {
+      let next = index + 2; while (next < content.length && !['\r', '\n'].includes(content[next])) next++;
+      directive(source, start + index, start + next, content.slice(index + 2, next), 'js', filename, output); index = next;
+    } else if (content.startsWith('/*', index)) {
+      const finish = content.indexOf('*/', index + 2), next = finish < 0 ? content.length : finish + 2;
+      directive(source, start + index, start + next, content.slice(index + 2, finish < 0 ? next : finish), 'js', filename, output); index = next;
+    } else index++;
+  }
+}
+function quoteEnd(source, index, quote, end = source.length) {
+  for (let cursor = index + 1; cursor < end; cursor++) {
+    if (source[cursor] === '\\') cursor++;
+    else if (source[cursor] === quote) return cursor + 1;
+  }
+  return end;
+}
+function styleComments(source, start, end, filename, output) {
+  for (let cursor = start; cursor < end;) {
+    if (['"', "'"].includes(source[cursor])) cursor = quoteEnd(source, cursor, source[cursor], end);
+    else if (source.startsWith('/*', cursor)) {
+      const finish = source.indexOf('*/', cursor + 2), next = finish < 0 || finish >= end ? end : finish + 2;
+      directive(source, cursor, next, source.slice(cursor + 2, next - 2), 'css', filename, output); cursor = next;
+    } else cursor++;
+  }
+}
+function tagEnd(source, start) {
+  for (let cursor = start; cursor < source.length; cursor++) {
+    if (['"', "'"].includes(source[cursor])) cursor = quoteEnd(source, cursor, source[cursor]) - 1;
+    else if (source[cursor] === '>') return cursor + 1;
+  }
+  return source.length;
+}
+function interpolationEnd(source, start) {
+  for (let cursor = start + 2; cursor < source.length; cursor++) {
+    if (['"', "'", '`'].includes(source[cursor])) cursor = quoteEnd(source, cursor, source[cursor]) - 1;
+    else if (source.startsWith('}}', cursor)) return cursor + 2;
+  }
+  return source.length;
+}
+export function uniDirectives(source, filename) {
+  const output = []; let inTag = false;
+  for (let cursor = 0; cursor < source.length;) {
+    if (source.startsWith('<!--', cursor)) {
+      const finish = source.indexOf('-->', cursor + 4), next = finish < 0 ? source.length : finish + 3;
+      directive(source, cursor, next, source.slice(cursor + 4, finish < 0 ? next : finish), 'html', filename, output); cursor = next;
+    } else if (inTag && ['"', "'"].includes(source[cursor])) cursor = quoteEnd(source, cursor, source[cursor]);
+    else if (source.startsWith('{{', cursor)) cursor = interpolationEnd(source, cursor);
+    else {
+      const block = /^<(script|style)\b/i.exec(source.slice(cursor, cursor + 16));
+      if (block) {
+        const start = tagEnd(source, cursor), closing = new RegExp(`</${block[1]}\\s*>`, 'ig'); closing.lastIndex = start;
+        const match = closing.exec(source), end = match?.index ?? source.length;
+        if (block[1].toLowerCase() === 'script') {
+          const header = source.slice(cursor, start), language = /\blang\s*=\s*['"]([^'"]+)['"]/i.exec(header)?.[1];
+          scriptComments(source, start, end, filename, output, ['ts', 'typescript'].includes(language) ? ts.ScriptKind.TS : ts.ScriptKind.TSX);
+        }
+        else styleComments(source, start, end, filename, output);
+        cursor = match ? closing.lastIndex : source.length; inTag = false;
+      } else { if (source[cursor] === '<') inTag = true; else if (source[cursor] === '>') inTag = false; cursor++; }
+    }
+  }
+  return output;
+}

package/local-scope-uni-expressions.mjs

@@ -0,0 +1,101 @@
+// Interpret a bounded subset of uni-app conditions; never evaluate source code.
+// Grammar and macro families: https://uniapp.dcloud.net.cn/tutorial/platform.html
+const platforms = ['H5', 'APP-PLUS', 'APP-HARMONY', 'APP-ANDROID', 'APP-IOS', 'MP-WEIXIN', 'MP-ALIPAY',
+  'MP-BAIDU', 'MP-TOUTIAO', 'MP-LARK', 'MP-QQ', 'MP-KUAISHOU', 'MP-JD', 'MP-360', 'MP-HARMONY',
+  'MP-XHS', 'QUICKAPP-NATIVE', 'QUICKAPP-WEBVIEW-UNION', 'QUICKAPP-WEBVIEW-HUAWEI'];
+const flags = ['WEB', 'APP', 'APP-VUE', 'APP-NVUE', 'APP-PLUS-NVUE', 'APP-UVUE', 'MP',
+  'QUICKAPP-WEBVIEW', 'VUE2', 'VUE3', 'VUE3-VAPOR', 'UNI-APP-X'];
+const known = new Set([...platforms, ...flags]);
+export function uniConditionalError(filename, offset, reason, source = '') {
+  const prefix = (typeof source === 'string' ? source : '').slice(0, Math.max(0, offset)), lines = prefix.split(/\r\n|\r|\n/);
+  const line = lines.length, column = lines.at(-1).length + 1;
+  return Object.assign(new Error(`${filename}:${line}:${column}: ${reason}`), {
+    code: 'ENTROROVE_IMPORT_UNSUPPORTED', path: filename, line, column, loc: { start: { offset } } });
+}
+export function uniCondition(expression, fail) {
+  if (expression.length > 512) throw fail('Conditional expression exceeds its 512-character bound');
+  const tokens = expression.match(/uniVersion|[A-Za-z_][A-Za-z0-9_-]*|\d+(?:\.\d+)?|\|\||&&|>=|<=|===|!==|==|!=|[!()<>]|\S/g) ?? [];
+  if (!tokens.length || tokens.length > 128) throw fail('Conditional expression requires a bounded supported expression');
+  let cursor = 0, depth = 0;
+  const versions = [], macros = new Set();
+  const atom = () => {
+    if (++depth > 24) throw fail('Conditional expression exceeds its nesting bound');
+    let result; const token = tokens[cursor++];
+    if (token === '!') result = { kind: 'not', value: atom() };
+    else if (token === '(') { result = disjunction(); if (tokens[cursor++] !== ')') throw fail('Conditional parentheses are not balanced'); }
+    else if (token === 'uniVersion') {
+      const operator = tokens[cursor++], literal = tokens[cursor++], value = Number(literal);
+      if (!['>', '>=', '<', '<=', '==', '===', '!=', '!=='].includes(operator)
+        || !/^\d+(?:\.\d+)?$/.test(literal ?? '') || !Number.isFinite(value) || value > 1_000_000) {
+        throw fail('uniVersion requires a supported comparison with a finite nonnegative version literal');
+      }
+      versions.push(value); result = { kind: 'version', operator, value };
+    } else {
+      const name = token?.replaceAll('_', '-');
+      if (!known.has(name)) throw fail('Conditional macro is unknown; its build definition cannot be proven by this scanner');
+      macros.add(name); result = { kind: 'macro', name };
+    }
+    depth--; return result;
+  };
+  const conjunction = () => {
+    let left = atom();
+    while (tokens[cursor] === '&&') { cursor++; left = { kind: 'and', left, right: atom() }; }
+    return left;
+  };
+  const disjunction = () => {
+    let left = conjunction();
+    while (tokens[cursor] === '||') { cursor++; left = { kind: 'or', left, right: conjunction() }; }
+    return left;
+  };
+  const tree = disjunction();
+  if (cursor !== tokens.length) throw fail('Conditional expression uses unsupported syntax');
+  return { tree, versions, macros: [...macros], tokens: tokens.length };
+}
+export function evaluateUniCondition(node, context) {
+  if (node.kind === 'macro') return context.macros.has(node.name);
+  if (node.kind === 'not') return !evaluateUniCondition(node.value, context);
+  if (node.kind === 'and') return evaluateUniCondition(node.left, context) && evaluateUniCondition(node.right, context);
+  if (node.kind === 'or') return evaluateUniCondition(node.left, context) || evaluateUniCondition(node.right, context);
+  const a = context.version, b = node.value;
+  return ({ '>': () => a > b, '>=': () => a >= b, '<': () => a < b, '<=': () => a <= b,
+    '==': () => a === b, '===': () => a === b, '!=': () => a !== b, '!==': () => a !== b })[node.operator]();
+}
+function versionSamples(conditions, fail) {
+  const values = [...new Set(conditions.flatMap(condition => condition.versions))].sort((a, b) => a - b);
+  if (values.length > 8) throw fail('Conditional versions exceed their eight-boundary inspection limit');
+  const samples = new Set([0, ...values]);
+  for (let index = 0; index < values.length; index++) {
+    const previous = values[index - 1] ?? 0;
+    if (values[index] > previous) samples.add(previous + (values[index] - previous) / 2);
+  }
+  if (values.length) samples.add(values.at(-1) + 1);
+  return [...samples];
+}
+function platformMacros(platform, engine) {
+  const macros = new Set([platform, engine.endsWith('2') ? 'VUE2' : 'VUE3']);
+  if (platform === 'H5') macros.add('WEB');
+  if (platform.startsWith('MP-')) macros.add('MP');
+  if (platform.startsWith('QUICKAPP-WEBVIEW')) macros.add('QUICKAPP-WEBVIEW');
+  if (platform.startsWith('APP-')) {
+    macros.add('APP'); macros.add(engine.startsWith('x') ? 'APP-UVUE' : engine.startsWith('nvue') ? 'APP-NVUE' : 'APP-VUE');
+    if (engine.startsWith('nvue')) macros.add('APP-PLUS-NVUE');
+    if (platform !== 'APP-HARMONY' && !engine.startsWith('x')) macros.add('APP-PLUS');
+    if (!engine.startsWith('x')) { macros.delete('APP-ANDROID'); macros.delete('APP-IOS'); }
+  }
+  if (engine.startsWith('x')) macros.add('UNI-APP-X');
+  if (engine === 'x-vapor') macros.add('VUE3-VAPOR');
+  return macros;
+}
+export function uniConditionContexts(conditions, fail) {
+  const samples = versionSamples(conditions, fail), output = [], seen = new Set();
+  for (const platform of platforms) for (const engine of ['vue2', 'vue3', 'nvue2', 'nvue3', 'x', 'x-vapor']) for (const version of samples) {
+    if (engine.startsWith('nvue') && !platform.startsWith('APP-')) continue;
+    const context = { macros: platformMacros(platform, engine), version, label: `${platform}/${engine}` };
+    const key = conditions.map(condition => evaluateUniCondition(condition.tree, context) ? '1' : '0').join('');
+    if (!seen.has(key)) {
+      seen.add(key); output.push({ ...context, key });
+      if (output.length > 64) throw fail('Conditional compilation exceeds its 64-variant inspection bound');
+    }
+  }
+  return output;
+}

package/local-scope-workspaces.mjs

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import { scopeFail, scopePath, scopeRead, scopeTarget } from './local-scope-files.mjs';
+import { observeScopeDirectory } from './local-scope-read-set.mjs';
 
 async function manifest(root, relative, input) {
   try {
@@ -32,14 +33,25 @@ async function patterns(root, input) {
   } catch (error) { if (error.code !== 'ENOENT') throw error; }
   return { patterns: [...new Set(result)], metadata };
 }
+async function directoryNames(root, parent) {
+  const target = await scopeTarget(root, parent);
+  if (!target.stat.isDirectory()) scopeFail('ENTROROVE_PACKAGE_INVALID', 'workspace parent must be a real directory');
+  const names = [], directory = await fs.opendir(target.target);
+  for await (const entry of directory) {
+    if (names.length >= 10_000) scopeFail('ENTROROVE_SCOPE_LIMIT', 'workspace directory exceeds its bounded entry inspection');
+    names.push(entry.name);
+  }
+  return names.sort();
+}
 async function packageDirectories(root, pattern) {
   if (!pattern.includes('*')) { scopePath(pattern); return [pattern]; }
   if (!pattern.endsWith('/*') || pattern.slice(0, -2).includes('*')) scopeFail('ENTROROVE_PACKAGE_INVALID', 'workspace glob needs a literal parent and a single terminal wildcard');
   const parent = scopePath(pattern.slice(0, -2)); const item = await scopeTarget(root, parent, true);
   if (!item.exists) return [];
   if (!item.stat.isDirectory()) scopeFail('ENTROROVE_PACKAGE_INVALID', 'workspace parent must be a real directory');
-  const result = [];
-  for (const name of (await fs.readdir(item.target)).sort()) {
+  const result = [], names = await directoryNames(root, parent);
+  observeScopeDirectory(root, parent, names, () => directoryNames(root, parent));
+  for (const name of names) {
     const directory = `${parent}/${name}`; const target = await scopeTarget(root, directory);
     if (target.stat.isDirectory()) result.push(directory);
   }

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.skill-manifest/1.0",
   "name": "entrorove",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "endpoint": "https://entrorove.com",
   "requestSchemaVersion": "entrorove.skill.request/2.0",
   "supportedRequestSchemaVersions": [

package/mutation-client.mjs

@@ -20,6 +20,7 @@ import { scopeAmendmentRefreshAction } from './scope-amendment-reference.mjs';
 import { readMutationConnection as readConnection } from './mutation-connection-state.mjs';
 import { readMutationEnvironmentObservation } from './local-mutation-environment-observation.mjs';
 import { refreshExpiredMutationChallenge } from './mutation-challenge-refresh.mjs';
+import { scopeContextObservation, scopeContextSnapshotInput } from './scope-context-observation.mjs';
 
 const fields = ['taskId', 'flowId', 'stepId', 'leaseId', 'generation', 'runnerId', 'paths'];
 const fail = message => mutationFail14('ENTROROVE_MUTATION_CONNECTION_BINDING', message);
@@ -110,14 +111,14 @@ function passBinding(pass, challenge, attestation, options) {
       .some(field => canonical(pass[field]) !== canonical(challenge[field]))
     || canonical(pass.writeDelegation) !== canonical(challenge.writeDelegation)) fail('Mutation pass differs from its original signed challenge or actual M snapshot');
 }
-async function snapshot(input, challenge, state, location) {
+async function snapshot(input, challenge, state, location, contextAuthority) {
   if (!state.planned) {
     if (state.planStarted) {
       const recovered = await snapshotVerify14(input);
       state.planned = { snapshotId: recovered.receipt.snapshotId, snapshotDigest: recovered.receipt.snapshotDigest };
     } else {
       state.planStarted = true; await save(location, state);
-      try { state.planned = await snapshotPlan14({ ...input, paths: challenge.paths, contractDigest: challenge.scopeContractDigest }); }
+      try { state.planned = await snapshotPlan14({ ...input, paths: challenge.paths, contractDigest: challenge.scopeContractDigest }, { contextAuthority }); }
       catch (error) { delete state.planStarted; await save(location, state); throw error; }
     }
     await save(location, state);
@@ -149,7 +150,7 @@ async function authorizeCachedConnection(identity, pass, dependencies) {
   }
   return status;
 }
-async function connect(identity, local, mutator, location, dependencies) {
+async function connect(identity, local, mutator, location, dependencies, contextAuthority) {
   const state = await readConnection(location, identity);
   let challenged = state.challenged ?? await remote('challenged', 'mutation-snapshot-challenge',
     { ...Object.fromEntries(fields.map(field => [field, identity[field]])),
@@ -178,7 +179,7 @@ async function connect(identity, local, mutator, location, dependencies) {
     passBinding(state.issued.pass, challenge, state.attestation);
     return connected(identity, state);
   }
-  await snapshot(input, challenge, state, location);
+  await snapshot(input, challenge, state, location, contextAuthority);
   if (!state.attestation) {
     const observed = await attestMutationSnapshot14({ ...input, challenge, signerConfigPath: mutator.signerConfigPath });
     if (observed.verified !== true || observed.attestation.keyId !== mutator.mutationKeyId) fail('Actual mutation snapshot was not signed by its separate M key');
@@ -209,11 +210,13 @@ export async function connectMutation(repositoryRoot, input, dependencies) {
     if (target.exists && !target.stat.isFile()) fail('Mutation connection permits only an absent approved creation or a concrete existing file');
   }
   await bootstrapCloudMutationAuthority(dependencies);
+  const contextAuthority = await scopeContextObservation(local, location.root, dependencies.apiOrigin());
+  const observed = (await scopeContextSnapshotInput(local, location.root, contextAuthority, { initial: true })).input;
   const mutator = await preparePreservedMutationSigner(local);
   const identity = { ...original, repositoryRoot: location.root, apiOrigin: trustedOrigin(dependencies.apiOrigin()), mutationKeyId: mutator.mutationKeyId };
   const directory = path.join(location.directory, 'connections'); await privateMutationDirectory14(directory, { privateFrom: location.stateRoot });
   const file = path.join(directory, `${sha256(canonical(identity))}.json`), journal = { ...location, file };
-  return withStateLock(file, () => connect(identity, local, mutator, journal, dependencies));
+  return withStateLock(file, () => connect(identity, observed, mutator, journal, dependencies, contextAuthority));
 }
 function settlementBinding(output, pass, receipt, expectedSettlementId) {
   if (output?.settled !== true || typeof output.settlementId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(output.settlementId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entrorove/skill",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "type": "module",
   "bin": {
     "entrorove": "cli.mjs"
@@ -89,6 +89,13 @@
     "local-task-handoff-write-receipts.mjs",
     "remote-client.mjs",
     "scope-runner-client.mjs",
+    "scope-context-client.mjs",
+    "scope-context-observer.mjs",
+    "scope-context-observation.mjs",
+    "scope-context-remote.mjs",
+    "scope-context-state.mjs",
+    "scope-context-wire.mjs",
+    "scope-context-release.mjs",
     "scope-amendment-client.mjs",
     "scope-amendment-state.mjs",
     "scope-amendment-wire.mjs",
@@ -304,7 +311,15 @@
     "package-archive.mjs",
     "package-replacement.mjs",
     "rollback-history.mjs",
-    "rollback-runner.mjs"
+    "rollback-runner.mjs",
+    "scope-context-journal.mjs",
+    "cloud-locale.mjs",
+    "cloud-locale.d.mts",
+    "local-scope-uni-expressions.mjs",
+    "local-scope-uni-directives.mjs",
+    "local-scope-uni-conditional.mjs",
+    "local-scope-uni-build.mjs",
+    "local-scope-read-set.mjs"
   ],
   "scripts": {
     "test": "node test/run.mjs",