@git-stunts/git-warp 12.0.0 → 12.2.0

package/src/domain/warp/patch.methods.js

@@ -530,6 +530,14 @@ export function join(otherState) {
   // Update cached state
   this._cachedState = mergedState;
 
+  // Invalidate derived caches (C1) — join changes underlying state
+  this._materializedGraph = null;
+  this._logicalIndex = null;
+  this._propertyReader = null;
+  this._cachedViewHash = null;
+  this._cachedIndexTree = null;
+  this._stateDirty = true;
+
   return { state: mergedState, receipt };
 }
 

package/src/domain/warp/query.methods.js

@@ -312,14 +312,16 @@ export function query() {
  * @this {import('../WarpGraph.js').default}
  * @param {string} name - Observer name
  * @param {Object} config - Observer configuration
- * @param {string} config.match - Glob pattern for visible nodes
+ * @param {string|string[]} config.match - Glob pattern(s) for visible nodes
  * @param {string[]} [config.expose] - Property keys to include
  * @param {string[]} [config.redact] - Property keys to exclude
  * @returns {Promise<import('../services/ObserverView.js').default>} A read-only observer view
  */
 export async function observer(name, config) {
-  if (!config || typeof config.match !== 'string') {
-    throw new Error('observer config.match must be a string');
+  /** @param {unknown} m */
+  const isValidMatch = (m) => typeof m === 'string' || (Array.isArray(m) && m.length > 0 && m.every(/** @param {unknown} i */ i => typeof i === 'string'));
+  if (!config || !isValidMatch(config.match)) {
+    throw new Error('observer config.match must be a non-empty string or non-empty array of strings');
   }
   await this._ensureFreshState();
   return new ObserverView({ name, config, graph: this });
@@ -330,11 +332,11 @@ export async function observer(name, config) {
  *
  * @this {import('../WarpGraph.js').default}
  * @param {Object} configA - Observer configuration for A
- * @param {string} configA.match - Glob pattern for visible nodes
+ * @param {string|string[]} configA.match - Glob pattern(s) for visible nodes
  * @param {string[]} [configA.expose] - Property keys to include
  * @param {string[]} [configA.redact] - Property keys to exclude
  * @param {Object} configB - Observer configuration for B
- * @param {string} configB.match - Glob pattern for visible nodes
+ * @param {string|string[]} configB.match - Glob pattern(s) for visible nodes
  * @param {string[]} [configB.expose] - Property keys to include
  * @param {string[]} [configB.redact] - Property keys to exclude
  * @returns {Promise<{cost: number, breakdown: {nodeLoss: number, edgeLoss: number, propLoss: number}}>}

package/src/domain/warp/subscribe.methods.js

@@ -6,6 +6,7 @@
  */
 
 import { diffStates, isEmptyDiff } from '../services/StateDiff.js';
+import { matchGlob } from '../utils/matchGlob.js';
 
 /**
  * Subscribes to graph changes.
@@ -101,13 +102,13 @@ export function subscribe({ onChange, onError, replay = false }) {
  * be at least 1000ms.
  *
  * @this {import('../WarpGraph.js').default}
- * @param {string} pattern - Glob pattern (e.g., 'user:*', 'order:123', '*')
+ * @param {string|string[]} pattern - Glob pattern(s) (e.g., 'user:*', 'order:123', '*')
  * @param {Object} options - Watch options
  * @param {(diff: import('../services/StateDiff.js').StateDiffResult) => void} options.onChange - Called with filtered diff when matching changes occur
  * @param {(error: Error) => void} [options.onError] - Called if onChange throws an error
  * @param {number} [options.poll] - Poll interval in ms (min 1000); checks frontier and auto-materializes
  * @returns {{unsubscribe: () => void}} Subscription handle
- * @throws {Error} If pattern is not a string
+ * @throws {Error} If pattern is not a string or array of strings
  * @throws {Error} If onChange is not a function
  * @throws {Error} If poll is provided but less than 1000
  *
@@ -130,31 +131,22 @@ export function subscribe({ onChange, onError, replay = false }) {
  * unsubscribe();
  */
 export function watch(pattern, { onChange, onError, poll }) {
-  if (typeof pattern !== 'string') {
-    throw new Error('pattern must be a string');
+  const isValidPattern = (/** @type {string|string[]} */ p) => typeof p === 'string' || (Array.isArray(p) && p.length > 0 && p.every(i => typeof i === 'string'));
+  if (!isValidPattern(pattern)) {
+    throw new Error('pattern must be a non-empty string or non-empty array of strings');
   }
   if (typeof onChange !== 'function') {
     throw new Error('onChange must be a function');
   }
   if (poll !== undefined) {
-    if (typeof poll !== 'number' || poll < 1000) {
-      throw new Error('poll must be a number >= 1000');
+    if (typeof poll !== 'number' || !Number.isFinite(poll) || poll < 1000) {
+      throw new Error('poll must be a finite number >= 1000');
     }
   }
 
-  // Pattern matching: same logic as QueryBuilder.match()
-  // Pre-compile pattern matcher once for performance
+  // Pattern matching logic
   /** @type {(nodeId: string) => boolean} */
-  let matchesPattern;
-  if (pattern === '*') {
-    matchesPattern = () => true;
-  } else if (pattern.includes('*')) {
-    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
-    matchesPattern = (/** @type {string} */ nodeId) => regex.test(nodeId);
-  } else {
-    matchesPattern = (/** @type {string} */ nodeId) => nodeId === pattern;
-  }
+  const matchesPattern = (nodeId) => matchGlob(pattern, nodeId);
 
   // Filtered onChange that only passes matching changes
   const filteredOnChange = (/** @type {import('../services/StateDiff.js').StateDiffResult} */ diff) => {
@@ -194,7 +186,7 @@ export function watch(pattern, { onChange, onError, poll }) {
   /** @type {ReturnType<typeof setInterval>|null} */
   let pollIntervalId = null;
   let pollInFlight = false;
-  if (poll) {
+  if (poll !== undefined) {
     pollIntervalId = setInterval(() => {
       if (pollInFlight) {
         return;

package/src/infrastructure/adapters/GitGraphAdapter.js

@@ -575,8 +575,8 @@ export default class GitGraphAdapter extends GraphPersistencePort {
   async compareAndSwapRef(ref, newOid, expectedOid) {
     this._validateRef(ref);
     this._validateOid(newOid);
-    // null means "ref must not exist" → use zero OID
-    const oldArg = expectedOid || '0'.repeat(newOid.length);
+    // null means "ref must not exist" → use zero OID (always 40 chars for SHA-1)
+    const oldArg = expectedOid || '0'.repeat(40);
     if (expectedOid) {
       this._validateOid(expectedOid);
     }