@deepblend/dsh-blender-provider-local 0.2.19 → 0.3.0

package/lib/index.js

@@ -706,9 +706,17 @@ export default class LocalBlenderRuntime extends Service {
       // bare names against the provider's scrubbed PATH. Relative paths with
       // separators are rejected by the service itself.
       const resolved = await this.ctx.subprocess.resolveExecutable(requested, undefined, options.signal)
+      if (options.signal?.aborted) {
+        throw new BlenderError(BlenderErrorCode.ABORTED, 'Blender executable resolution was cancelled.')
+      }
       const canonical = this._assertAllowed(resolved, requested)
       return { resolved: canonical, requested, error: null }
     } catch (cause) {
+      if (options.signal?.aborted || cause?.name === 'AbortError') {
+        return { resolved: null, requested, error: new BlenderError(
+          BlenderErrorCode.ABORTED, 'Blender executable resolution was cancelled.', { cause },
+        ) }
+      }
       // The ADVICE travels with the failure, because two readers need the same sentence: the settings
       // card a human opens and the capability text a model reads. Composing it in either of them would
       // be a second copy of "what to do when there is no Blender", and this repository has paid for
@@ -1342,6 +1350,9 @@ export default class LocalBlenderRuntime extends Service {
    * @returns {Promise<import('@deepblend/dsh-blender-contracts').BlenderCapabilities>}
    */
   async getCapabilities(options = {}) {
+    if (options.signal?.aborted) {
+      throw new BlenderError(BlenderErrorCode.ABORTED, 'Blender capability probe was cancelled.')
+    }
     const cacheKey = this._requestedBlenderPath()
     const cached = this._capabilitiesCache.get(cacheKey)
     const now = Date.now()
@@ -1350,6 +1361,7 @@ export default class LocalBlenderRuntime extends Service {
     }
 
     const resolved = await this.resolveBlenderExecutable({ signal: options.signal })
+    if (resolved.error?.code === BlenderErrorCode.ABORTED) throw resolved.error
     if (resolved.resolved === null || resolved.error !== null) {
       const absent = this._absentCapabilities(resolved, resolved.error)
       this._capabilitiesCache.set(cacheKey, absent)
@@ -1474,6 +1486,7 @@ export default class LocalBlenderRuntime extends Service {
    * @param {string} [request.projectRoot]
    * @param {string} [request.jobId]
    * @param {AbortSignal} [request.signal]
+   * @param {boolean} [request.session] - false forces an isolated batch process, even when compile_scene is configured for a kept/live session.
    * @returns {Promise<{report: object, envelope: object, durationMs: number, stdout: string, stderr: string}>}
    */
   async compileScene(request) {
@@ -1484,43 +1497,42 @@ export default class LocalBlenderRuntime extends Service {
     // checkpoint that belonged to a different one. Passing the path explicitly removes the dependency
     // on a working directory that a kept process does not have per request.
     const { directory: requestDirectory } = this._createWorkingDirectory()
-    const outputBlend = join(requestDirectory, 'result.blend')
-    if (typeof request?.sceneSpecPath !== 'string' || request.sceneSpecPath.length === 0) {
-      throw new BlenderError(
-        BlenderErrorCode.SCENE_SPEC_INVALID,
-        'compileScene needs an absolute path to a SceneSpec document.',
-      )
-    }
-
-    const args = ['--scene-spec', request.sceneSpecPath, '--output-blend', outputBlend]
-    if (request.profile !== undefined) args.push('--profile', String(request.profile))
-    if (request.projectRoot !== undefined) args.push('--project-root', request.projectRoot)
+    try {
+      const outputBlend = join(requestDirectory, 'result.blend')
+      if (typeof request?.sceneSpecPath !== 'string' || request.sceneSpecPath.length === 0) {
+        throw new BlenderError(
+          BlenderErrorCode.SCENE_SPEC_INVALID,
+          'compileScene needs an absolute path to a SceneSpec document.',
+        )
+      }
 
-    const run = await this.runBootstrap(
-      { action: 'compile_scene', jobId: request.jobId },
-      {
-        signal: request.signal,
-        args,
-        projectRoot: request.projectRoot,
-        // NOT `onWorkingDirectory` here: the callback has to name the directory that HOLDS the
-        // checkpoint, and that is this method's own (`runBootstrap` would name its invocation
-        // directory, which in a session is a different one). One owner for one path.
-      },
-    )
+      const args = ['--scene-spec', request.sceneSpecPath, '--output-blend', outputBlend]
+      if (request.profile !== undefined) args.push('--profile', String(request.profile))
+      if (request.projectRoot !== undefined) args.push('--project-root', request.projectRoot)
+
+      const run = await this.runBootstrap(
+        { action: 'compile_scene', jobId: request.jobId },
+        {
+          signal: request.signal,
+          session: request.session,
+          args,
+          projectRoot: request.projectRoot,
+          // This method owns the directory containing the checkpoint; the
+          // bootstrap invocation has a separate directory in batch mode.
+        },
+      )
 
-    // The caller moves the checkpoint somewhere durable before this directory goes away, which is what
-    // lets a compile failure leave no trace in the project.
-    if (typeof request.onWorkingDirectory === 'function') {
-      await request.onWorkingDirectory({ directory: requestDirectory, envelope: run.envelope, jobId: request.jobId })
-    }
+      // Await consumption before cleanup, including asynchronous moves/copies.
+      if (typeof request.onWorkingDirectory === 'function') {
+        await request.onWorkingDirectory({ directory: requestDirectory, envelope: run.envelope, jobId: request.jobId })
+      }
 
-    const report = run.envelope.result ?? {}
-    return {
-      report,
-      envelope: run.envelope,
-      durationMs: run.durationMs,
-      stdout: run.stdout,
-      stderr: run.stderr,
+      const report = run.envelope.result ?? {}
+      return { report, envelope: run.envelope, durationMs: run.durationMs, stdout: run.stdout, stderr: run.stderr }
+    } finally {
+      // Includes compile failure, cancellation and consumer callback failure.
+      // Hosts never have to guess provider-owned temporary paths to remove them.
+      this._cleanup(requestDirectory)
     }
   }
 
@@ -1538,6 +1550,7 @@ export default class LocalBlenderRuntime extends Service {
    * @param {number} [request.frame]
    * @param {string} [request.jobId]
    * @param {AbortSignal} [request.signal]
+   * @param {boolean} [request.session] - false forces an isolated batch process; omission preserves configured session routing.
    * @returns {Promise<{report: object, envelope: object, durationMs: number, stdout: string, stderr: string}>}
    */
   async renderPreview(request) {
@@ -1561,7 +1574,7 @@ export default class LocalBlenderRuntime extends Service {
 
     const run = await this.runBootstrap(
       { action: 'render_preview', jobId: request.jobId },
-      { signal: request.signal, args, onWorkingDirectory: request.onWorkingDirectory },
+      { signal: request.signal, session: request.session, args, onWorkingDirectory: request.onWorkingDirectory },
     )
 
     const report = run.envelope.result ?? {}
@@ -1604,6 +1617,7 @@ export default class LocalBlenderRuntime extends Service {
    * @param {number} [request.samples]
    * @param {string} [request.jobId]
    * @param {AbortSignal} [request.signal]
+   * @param {boolean} [request.session] - false forces batch isolation; omission preserves configured session routing.
    * @returns {Promise<{report: object, pngs: Record<string, Buffer>, envelope: object, durationMs: number}>}
    */
   /**
@@ -1894,6 +1908,7 @@ export default class LocalBlenderRuntime extends Service {
       { action: 'render_views', jobId: request.jobId },
       {
         signal: request.signal,
+        session: request.session,
         args: ['--views', 'views.json'],
         // The plan names outputs by BARE file name: Blender must write somewhere
         // that dies with the invocation, or a failed render would leave images

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepblend/dsh-blender-provider-local",
-  "version": "0.2.19",
+  "version": "0.3.0",
   "type": "module",
   "description": "Local Blender Provider: the BlenderRuntime Service over ctx.subprocess (batch execution).",
   "main": "lib/index.js",
@@ -11,7 +11,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@deepblend/dsh-blender-contracts": "0.2.19"
+    "@deepblend/dsh-blender-contracts": "0.3.0"
   },
   "license": "MIT",
   "repository": {

package/python/bootstrap.py

@@ -218,10 +218,12 @@ def action_compile_scene(request, options):
 
     report_progress("validate", 92)
     validation = validate_scene(bpy.context.scene, spec, guard)
+    objects = describe_objects()
 
     payload = {
         "sceneSpec": spec_path,
-        "objects": describe_objects(),
+        "objects": objects,
+        "world": report["world"],
         "actions": report["actions"],
         "renderConfig": report["renderConfig"],
         "engine": report["engine"],
@@ -262,7 +264,7 @@ def action_compile_scene(request, options):
             )
         ],
         "validation": validation,
-        "sceneFingerprint": scene_fingerprint(spec, describe_objects()),
+        "sceneFingerprint": scene_fingerprint(spec, objects),
     }
 
     # The checkpoint is written even when validation reported errors: the caller

package/python/deepblend_anisotropy.py

@@ -0,0 +1,110 @@
+"""Explicit Principled anisotropy with Blender UV or radial tangent directions.
+
+Blender 5.2's Principled Anisotropic/Anisotropic Rotation are Cycles-only.
+Rotation is measured in turns, not radians. RADIAL uses Blender's cylindrical
+projection about the object's local X/Y/Z axis; UV_MAP uses the named UV map.
+https://docs.blender.org/manual/en/5.2/render/shader_nodes/shader/principled.html
+https://docs.blender.org/manual/en/4.3/render/shader_nodes/input/tangent.html
+"""
+from deepblend_util import ActionError
+from deepblend_images import validate_image_uv_usage, validate_procedural_uv_usage
+
+KEYS = ('anisotropic', 'anisotropicRotation')
+
+
+def anisotropy_state(spec, tracks=()):
+    parameters = spec.get('parameters') or {}
+    animations = [track for track in tracks if track.get('targetKind') == 'material'
+                  and track.get('targetEntityId') == spec['id'] and track.get('property') in KEYS]
+    requested = spec.get('tangent') is not None or animations or any(key in parameters for key in KEYS)
+    direction_required = any(parameters.get(key, 0) != 0 for key in KEYS) or any(
+        key.get('value', 0) != 0 for track in animations for key in track.get('keyframes', []))
+    active = parameters.get('anisotropic', 0) > 0 or any(
+        key.get('value', 0) > 0 for track in animations if track['property'] == 'anisotropic'
+        for key in track.get('keyframes', []))
+    return requested, direction_required, active
+
+
+def validate_anisotropy_material(spec, tracks=()):
+    requested, direction_required, active = anisotropy_state(spec, tracks)
+    if requested and spec.get('shader') == 'emission':
+        raise ActionError('SCENE_VALIDATION_FAILED', 'anisotropy requires a principled or glass material', {'materialId': spec['id']})
+    if direction_required and spec.get('tangent') is None:
+        raise ActionError('SCENE_VALIDATION_FAILED', 'nonzero anisotropy or rotation requires an explicit tangent', {'materialId': spec['id']})
+    return active
+
+
+def build_anisotropy(material, principled, spec):
+    """Connect a real tangent node; do not depend on Blender's implicit UV fallback."""
+    requested, _, _ = anisotropy_state(spec)
+    if not requested:
+        return
+    validate_anisotropy_material(spec)
+    for socket in ('Anisotropic', 'Anisotropic Rotation', 'Tangent'):
+        if principled.inputs.get(socket) is None:
+            raise ActionError('SCENE_VALIDATION_FAILED', 'this Blender build lacks Principled ' + socket, {'materialId': spec['id']})
+    binding = spec.get('tangent')
+    if binding is None:
+        return
+    node = material.node_tree.nodes.new('ShaderNodeTangent')
+    node.name = 'db_anisotropic_tangent'
+    node.location = (-270, -740)
+    if binding['mode'] == 'uv':
+        node.direction_type = 'UV_MAP'
+        node.uv_map = binding['uvMap']
+    elif binding['mode'] == 'radial':
+        node.direction_type = 'RADIAL'
+        node.axis = binding['axis'].upper()
+    else:
+        raise ActionError('SCENE_VALIDATION_FAILED', 'unknown anisotropic tangent mode', {'materialId': spec['id']})
+    material.node_tree.links.new(node.outputs['Tangent'], principled.inputs['Tangent'])
+
+
+def validate_anisotropy_usage(spec, mesh, engine, tracks=(), uv_layers=None):
+    """Called only for materials actually used by a mesh face, after slot overrides."""
+    active = validate_anisotropy_material(spec, tracks)
+    if active and engine != 'CYCLES':
+        raise ActionError('SCENE_VALIDATION_FAILED', 'Principled anisotropy requires Cycles for this used material',
+                          {'materialId': spec['id'], 'entityId': mesh.get('deepblend_id'), 'engine': engine})
+    _, direction_required, _ = anisotropy_state(spec, tracks)
+    binding = spec.get('tangent')
+    layers = uv_layers if uv_layers is not None else getattr(mesh.data, 'uv_layers', None)
+    if direction_required and binding and binding['mode'] == 'uv' and (layers is None or layers.get(binding['uvMap']) is None):
+        raise ActionError('SCENE_VALIDATION_FAILED', 'anisotropic material requires its named UV map on the used mesh',
+                          {'materialId': spec['id'], 'entityId': mesh.get('deepblend_id'),
+                           'partId': mesh.get('deepblend_part_id'), 'uvMap': binding['uvMap']})
+    return active
+
+
+def validate_native_material_usage(spec, material, obj, engine, tracks, depsgraph):
+    """Inspect evaluated faces without converting or changing the imported object.
+
+    Curves, surfaces and text can render a material while remaining native data.
+    A named UV map must exist on the evaluated surface; implicit fallback is not
+    proof. Unused slots and unrelated materials never trigger this inspection.
+    """
+    _, direction_required, active = anisotropy_state(spec, tracks)
+    assigned = {index for index, slot in enumerate(obj.material_slots) if slot.material == material}
+    if not assigned or not (direction_required or active or spec.get('images') or
+                            (spec.get('texture') or {}).get('coordinates') == 'uv'):
+        return False
+    evaluated = obj.evaluated_get(depsgraph)
+    try:
+        surface = evaluated.to_mesh(preserve_all_data_layers=True, depsgraph=depsgraph)
+        if surface is None:
+            raise ActionError('SCENE_VALIDATION_FAILED', 'cannot verify anisotropic direction on this native surface',
+                              {'materialId': spec['id'], 'entityId': obj.get('deepblend_id'), 'objectType': obj.type})
+        if any(polygon.material_index in assigned for polygon in surface.polygons):
+            validate_image_uv_usage(spec, obj, surface.uv_layers)
+            validate_procedural_uv_usage(spec, obj, surface.uv_layers)
+            return validate_anisotropy_usage(spec, obj, engine, tracks, uv_layers=surface.uv_layers)
+        return False
+    finally:
+        evaluated.to_mesh_clear()
+
+
+def validate_anisotropy_render_engine(scene, engine):
+    """Keep the saved scene's used-material requirement through render overrides."""
+    if scene.get('deepblend_requires_cycles', False) and engine != 'CYCLES':
+        raise ActionError('SCENE_VALIDATION_FAILED', 'this checkpoint uses animated or static anisotropy and requires Cycles',
+                          {'engine': engine, 'requiredEngine': 'CYCLES'})

package/python/deepblend_asset_bundle.py

@@ -0,0 +1,193 @@
+"""Verify managed glTF bundles before any scene mutation; no bpy dependency."""
+import hashlib,json,os,posixpath,re,struct
+from urllib.parse import unquote
+from deepblend_util import ActionError
+from deepblend_obj_resources import obj_libraries,mtl_images
+LOCK='.deepblend-lock.json'
+MAX_FILES=256
+MAX_LOCK=1024*1024
+MAX_JSON=16*1024*1024
+MAX_CHUNKS=1024
+
+def fail(message,code='ASSET_REQUEST_INVALID'):
+    raise ActionError(code,message)
+
+def member_path(path):
+    if not isinstance(path,str) or not path or len(path)>1024 or '\\' in path or path.startswith('/') or re.search(r'[\x00-\x1f]',path) or any(not p or p in ('.','..') or re.search(r'[:<>"|?*]',p) for p in path.split('/')):
+        fail('Asset bundle members need contained, portable relative paths.')
+    return path
+
+def inside(root,path):
+    base=os.path.realpath(root);target=os.path.realpath(os.path.join(base,path))
+    if target!=base and not target.startswith(base+os.sep):
+        fail('An asset bundle path escapes its directory.','PATH_OUTSIDE_WORKSPACE')
+    return target
+
+def read_bytes(path,limit):
+    try:
+        if os.path.getsize(path)>limit:
+            fail('The asset bundle metadata exceeds its byte limit.','ASSET_TOO_LARGE')
+        with open(path,'rb') as source:
+            data=source.read(limit+1)
+        if len(data)>limit:
+            fail('The asset bundle metadata exceeds its byte limit.','ASSET_TOO_LARGE')
+        return data
+    except OSError:
+        fail('An asset bundle file is missing.','ASSET_MISSING')
+
+def read_json(path,limit):
+    data=read_bytes(path,limit)
+    try:return data,json.loads(data)
+    except (ValueError,UnicodeError):fail('The asset bundle metadata cannot be parsed.','ASSET_CONTENT_MISMATCH')
+
+def parse_document(data):
+    try:return json.loads(data.decode('utf-8-sig'),parse_constant=lambda value:fail('Non-finite glTF JSON value.','ASSET_CONTENT_MISMATCH'))
+    except (ValueError,UnicodeError):fail('The glTF metadata cannot be parsed.','ASSET_CONTENT_MISMATCH')
+
+def read_document(path,format='gltf',include_bin_location=False):
+    if format=='gltf':return parse_document(read_bytes(path,MAX_JSON)),None
+    if format!='glb':fail('Unsupported asset bundle format.')
+    try:
+        with open(path,'rb') as source:
+            size=os.fstat(source.fileno()).st_size
+            def read(offset,length):
+                source.seek(offset);data=source.read(length)
+                if len(data)!=length:fail('The GLB is truncated.','ASSET_CONTENT_MISMATCH')
+                return data
+            if size<20:fail('The GLB header is truncated.','ASSET_CONTENT_MISMATCH')
+            magic,version,declared=struct.unpack('<4sII',read(0,12))
+            if magic!=b'glTF' or version!=2 or declared!=size:fail('The GLB must be a complete version 2 container.','ASSET_CONTENT_MISMATCH')
+            offset=12;document=None;bin_bytes=None;bin_offset=None;chunks=0;json_seen=False
+            while offset<size:
+                chunks+=1
+                if chunks>MAX_CHUNKS:fail('The GLB exceeds the chunk inspection limit.','ASSET_TOO_LARGE')
+                if offset+8>size:fail('The GLB chunk header is truncated.','ASSET_CONTENT_MISMATCH')
+                length,kind=struct.unpack('<II',read(offset,8))
+                if length%4 or offset+8+length>size:fail('The GLB chunk length is invalid.','ASSET_CONTENT_MISMATCH')
+                if chunks==1 and kind!=0x4e4f534a:fail('The first GLB chunk must contain JSON.','ASSET_CONTENT_MISMATCH')
+                if kind==0x4e4f534a:
+                    if json_seen:fail('The GLB contains duplicate JSON chunks.','ASSET_CONTENT_MISMATCH')
+                    if length>MAX_JSON:fail('The GLB JSON exceeds 16 MiB.','ASSET_TOO_LARGE')
+                    json_seen=True;document=parse_document(read(offset+8,length))
+                elif kind==0x004e4942:
+                    if chunks!=2 or bin_bytes is not None:fail('The GLB BIN must be its second chunk.','ASSET_CONTENT_MISMATCH')
+                    bin_bytes=length;bin_offset=offset+8
+                offset+=8+length
+            if not isinstance(document,dict) or not isinstance(document.get('asset'),dict) or document['asset'].get('version')!='2.0':fail('The GLB JSON must declare glTF 2.0.','ASSET_CONTENT_MISMATCH')
+            return document,({'offset':bin_offset,'bytes':bin_bytes} if include_bin_location and bin_bytes is not None else bin_bytes)
+    except OSError:fail('A glTF asset file is missing.','ASSET_MISSING')
+
+def resources(document,entrypoint,bin_bytes=None):
+    if not isinstance(document,dict) or not isinstance(document.get('asset'),dict) or document['asset'].get('version')!='2.0':
+        fail('The glTF JSON must declare version 2.0.','ASSET_CONTENT_MISMATCH')
+    paths=set()
+    for key in ('buffers','images'):
+        entries=document.get(key,[])
+        if not isinstance(entries,list):fail('glTF resources must be arrays.')
+        for index,item in enumerate(entries):
+            if not isinstance(item,dict):fail('Invalid glTF resource entry.')
+            uri=item.get('uri')
+            if uri is None and 'uri' not in item:
+                if key=='buffers' and (index!=0 or bin_bytes is None or type(item.get('byteLength')) is not int or not 0<=item['byteLength']<=bin_bytes or bin_bytes-item['byteLength']>3):fail('An embedded buffer requires the first GLB buffer and a matching BIN chunk.')
+                continue
+            if not isinstance(uri,str) or not uri:fail('glTF resource URIs must be nonempty strings.')
+            if uri.startswith('data:'):
+                if not re.fullmatch(r'data:[^,]*;base64,[A-Za-z0-9+/]*={0,2}',uri) or len(uri.split(',')[1])%4:fail('glTF embedded resources need valid base64 data URIs.')
+                continue
+            if uri.startswith('/') or '\\' in uri or '?' in uri or '#' in uri or re.match(r'^[a-z][a-z0-9+.-]*:',uri,re.I):fail('glTF resources must use relative file URIs or embedded data.')
+            if re.search(r'%(?![a-f0-9]{2})',uri,re.I):fail('A glTF resource URI has invalid percent encoding.')
+            try:decoded=unquote(uri,errors='strict')
+            except UnicodeError:fail('A glTF resource URI has invalid percent encoding.')
+            if decoded.startswith('/') or '\\' in decoded or re.search(r'[\x00-\x1f]',decoded):fail('Invalid glTF resource path.')
+            path=member_path(posixpath.normpath(posixpath.join(posixpath.dirname(entrypoint),decoded)))
+            if path==LOCK:fail('A glTF resource collides with the reserved bundle lock.')
+            paths.add(path)
+    queue=[(document,False)];index=0
+    while index<len(queue):
+        if index>500000:fail('The glTF resource graph exceeds its inspection limit.','ASSET_TOO_LARGE')
+        value,extension=queue[index];index+=1
+        if isinstance(value,dict):
+            if extension and isinstance(value.get('uri'),str) and not value['uri'].lower().startswith('data:'):fail('External URI resources inside glTF extensions need a supported dependency profile.')
+            queue.extend((child,extension or key=='extensions') for key,child in value.items() if isinstance(child,(dict,list)))
+        elif isinstance(value,list):queue.extend((child,extension) for child in value if isinstance(child,(dict,list)))
+    if len(paths)+1>MAX_FILES:fail('The glTF bundle exceeds its file limit.','ASSET_TOO_LARGE')
+    folded=set()
+    for path in [entrypoint]+list(paths):
+        key=path.lower()
+        if key in folded and path!=entrypoint:fail('glTF resource paths collide on case-insensitive filesystems.')
+        folded.add(key)
+    return paths
+
+def verify_asset_bundle(project_root,asset):
+    match=re.fullmatch(r'assets/bundles/([a-f0-9]{64})/(.+)',asset.get('path',''))
+    if not match:return None
+    root=inside(project_root,'assets/bundles/'+match.group(1));data=read_bytes(inside(root,LOCK),MAX_LOCK)
+    if hashlib.sha256(data).hexdigest()!=match.group(1):fail('The asset bundle lock changed.','ASSET_HASH_MISMATCH')
+    try:manifest=json.loads(data)
+    except (ValueError,UnicodeError):fail('The asset bundle lock cannot be parsed.','ASSET_CONTENT_MISMATCH')
+    if not isinstance(manifest,dict) or manifest.get('schemaVersion')!='deepblend.asset-bundle/v1' or manifest.get('entrypoint')!=match.group(2) or not isinstance(manifest.get('files'),list) or not 1<=len(manifest['files'])<=MAX_FILES:
+        fail('The asset bundle lock has an invalid shape or entrypoint.')
+    member_path(manifest['entrypoint']);format=manifest.get('format','gltf')
+    if format not in ('gltf','glb','obj') or (asset.get('type') and asset['type']!=format):fail('The asset bundle format does not match its declaration.')
+    members={};folded=set();total=0
+    for member in manifest['files']:
+        if not isinstance(member,dict):fail('Invalid asset bundle member.')
+        path=member_path(member.get('path'));size=member.get('bytes');sha=member.get('sha256')
+        if path==LOCK or path in members or path.lower() in folded or not isinstance(sha,str) or not re.fullmatch(r'[a-f0-9]{64}',sha) or type(size) is not int or not 0<=size<=9007199254740991:
+            fail('The asset bundle lock contains invalid or duplicate members.')
+        file=inside(root,path);digest=hashlib.sha256();actual_size=0
+        try:
+            with open(file,'rb') as source:
+                for chunk in iter(lambda:source.read(64*1024),b''):
+                    actual_size+=len(chunk)
+                    if actual_size>size:fail('An asset bundle member changed size.','ASSET_HASH_MISMATCH')
+                    digest.update(chunk)
+        except OSError:fail('An asset bundle member is missing.','ASSET_MISSING')
+        if actual_size!=size or digest.hexdigest()!=sha:fail('An asset bundle member changed.','ASSET_HASH_MISMATCH')
+        members[path]=member;folded.add(path.lower());total+=size
+    main=members.get(manifest['entrypoint'])
+    if total>9007199254740991 or type(manifest.get('totalBytes')) is not int or manifest['totalBytes']!=total or main is None or (asset.get('sha256') and asset['sha256']!=main['sha256']):
+        fail('The asset bundle identity does not agree with its declaration.','ASSET_HASH_MISMATCH')
+    if format=='obj':paths=obj_resources(root,manifest['entrypoint'])
+    else:
+        document,bin_bytes=read_document(inside(root,manifest['entrypoint']),format)
+        paths=resources(document,manifest['entrypoint'],bin_bytes)
+    for path in paths:
+        if path not in members:fail('A glTF resource is not locked.')
+    return manifest
+
+def verify_unbundled_gltf_asset(project_root,asset):
+    if asset.get('type') not in ('gltf','glb') or re.match(r'assets/bundles/[a-f0-9]{64}/',asset.get('path','')):return
+    document,bin_bytes=read_document(inside(project_root,asset.get('path','')),asset['type'])
+    if resources(document,posixpath.basename(asset.get('path','')),bin_bytes):fail('This glTF/GLB has unlocked external resources. Reimport the local source with a containing sourceRoot.')
+
+
+def obj_reference(entrypoint,name):
+    if not name or name.startswith('/') or '\\' in name or re.match(r'^[a-z][a-z0-9+.-]*:',name,re.I):
+        fail('OBJ resources require portable relative file paths. No dependency URLs are fetched.')
+    path=member_path(posixpath.normpath(posixpath.join(posixpath.dirname(entrypoint),name)))
+    if path==LOCK:fail('An OBJ resource collides with the reserved bundle lock.')
+    return path
+
+def obj_resources(root,entrypoint):
+    libraries={obj_reference(entrypoint,name) for name in obj_libraries(inside(root,entrypoint))}
+    fallback=posixpath.splitext(entrypoint)[0]+'.mtl'
+    if os.path.exists(inside(root,fallback)):libraries.add(fallback)
+    paths=set(libraries);folded={entrypoint.lower():entrypoint}
+    def check(path):
+        previous=folded.get(path.lower())
+        if previous is not None and previous!=path:fail('OBJ resource paths collide on case-insensitive filesystems.')
+        folded[path.lower()]=path
+        if len(paths|{entrypoint})>MAX_FILES:fail('The OBJ bundle exceeds its resource file limit.','ASSET_TOO_LARGE')
+    for library in libraries:
+        check(library)
+        for name in mtl_images(inside(root,library)):
+            path=obj_reference(library,name);paths.add(path);check(path)
+    for path in paths:check(path)
+    return paths
+
+def verify_unbundled_obj_asset(project_root,asset):
+    if asset.get('type')!='obj' or re.match(r'assets/bundles/[a-f0-9]{64}/',asset.get('path','')):return
+    file=inside(project_root,asset.get('path',''));fallback=posixpath.splitext(asset.get('path',''))[0]+'.mtl'
+    if obj_libraries(file) or os.path.exists(inside(project_root,fallback)):
+        fail('This OBJ has unlocked material resources. Reimport the complete local source with a containing sourceRoot.')